@exode-team/kinescope.api 2.0.32

package/README.md

@@ -0,0 +1 @@
+## kinescope.api

package/dist/analytics-service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AnalyticsService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+import { BaseService } from './base-service';
+import { AnalyticsGetCustomRequest, AnalyticsGetCustomResponse } from './types';
+import { AnalyticsGetOverviewRequest, AnalyticsGetOverviewResponse } from './types';
+export declare class AnalyticsService extends BaseService {
+    /**
+     * Get overview
+     * @param {AnalyticsGetOverviewRequest} params
+     * @returns {Promise<AnalyticsGetOverviewResponse>}
+     */
+    getOverview(params: AnalyticsGetOverviewRequest): Promise<AnalyticsGetOverviewResponse>;
+    /**
+     * Get custom
+     * @param {AnalyticsGetCustomRequest} params
+     * @returns {Promise<AnalyticsGetCustomResponse>}
+     */
+    getCustom(params: AnalyticsGetCustomRequest): Promise<AnalyticsGetCustomResponse>;
+}

package/dist/analytics-service.js

@@ -0,0 +1,63 @@
+/**
+ * AnalyticsService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./base-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AnalyticsService = void 0;
+    const base_service_1 = require("./base-service");
+    class AnalyticsService extends base_service_1.BaseService {
+        /**
+         * Get overview
+         * @param {AnalyticsGetOverviewRequest} params
+         * @returns {Promise<AnalyticsGetOverviewResponse>}
+         */
+        getOverview(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi('https://api.kinescope.io/v1/analytics/overview', params, 'get');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+        /**
+         * Get custom
+         * @param {AnalyticsGetCustomRequest} params
+         * @returns {Promise<AnalyticsGetCustomResponse>}
+         */
+        getCustom(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi('https://api.kinescope.io/v1/analytics', params, 'get');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+    }
+    exports.AnalyticsService = AnalyticsService;
+});

package/dist/api.service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ApiService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+import { AnalyticsService } from './analytics-service';
+import { ProjectService } from './project-service';
+import { VideoService } from './video-service';
+export declare class ApiService {
+    constructor(apiToken: string);
+    /**
+     * AnalyticsService
+     * @type {AnalyticsService}
+     */
+    readonly analytics: AnalyticsService;
+    /**
+     * ProjectService
+     * @type {ProjectService}
+     */
+    readonly project: ProjectService;
+    /**
+     * VideoService
+     * @type {VideoService}
+     */
+    readonly video: VideoService;
+}

package/dist/api.service.js

@@ -0,0 +1,29 @@
+/**
+ * ApiService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./analytics-service", "./project-service", "./video-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ApiService = void 0;
+    const analytics_service_1 = require("./analytics-service");
+    const project_service_1 = require("./project-service");
+    const video_service_1 = require("./video-service");
+    class ApiService {
+        constructor(apiToken) {
+            this.analytics = new analytics_service_1.AnalyticsService(apiToken);
+            this.project = new project_service_1.ProjectService(apiToken);
+            this.video = new video_service_1.VideoService(apiToken);
+        }
+    }
+    exports.ApiService = ApiService;
+});

package/dist/base-service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BaseService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+/// <reference types="node" />
+import { Request, Response } from './types';
+export declare class BaseService {
+    /**
+     * Kinescope apiToken
+     */
+    private readonly apiToken;
+    /**
+     * Constructor
+     *
+     * @param apiToken - kinescope apiToken
+     */
+    constructor(apiToken: string);
+    /**
+     * Make request to Kinescope API
+     * @param {string} apiUrl
+     * @param {Request | File | Buffer} data
+     * @param {'post' | 'getMany'} httpMethod
+     * @param {Record} headers
+     * @returns {Promise<T>}
+     */
+    requestApi<T = Response>(apiUrl: string, data: Request | File | Buffer, httpMethod: 'post' | 'get' | 'put' | 'delete', headers?: Record<string, string>): Promise<T>;
+}

package/dist/base-service.js

@@ -0,0 +1,71 @@
+/**
+ * BaseService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "axios"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaseService = void 0;
+    const axios_1 = __importDefault(require("axios"));
+    class BaseService {
+        /**
+         * Constructor
+         *
+         * @param apiToken - kinescope apiToken
+         */
+        constructor(apiToken) {
+            this.apiToken = apiToken;
+        }
+        /**
+         * Make request to Kinescope API
+         * @param {string} apiUrl
+         * @param {Request | File | Buffer} data
+         * @param {'post' | 'getMany'} httpMethod
+         * @param {Record} headers
+         * @returns {Promise<T>}
+         */
+        requestApi(apiUrl, data, httpMethod, headers) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const config = {
+                    url: apiUrl,
+                    method: httpMethod,
+                    maxBodyLength: Infinity,
+                    data: httpMethod !== 'get' ? data : {},
+                    params: httpMethod === 'get' ? data : {},
+                    headers: Object.assign({ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': `Bearer ${this.apiToken}` }, headers),
+                };
+                try {
+                    const response = yield axios_1.default.request(config);
+                    return response.data;
+                }
+                catch (error) {
+                    const response = error.response;
+                    console.error(`[Error code is ${response === null || response === void 0 ? void 0 : response.status}] ${JSON.stringify(response === null || response === void 0 ? void 0 : response.data)}`);
+                    throw error;
+                }
+            });
+        }
+    }
+    exports.BaseService = BaseService;
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Index
+ *
+ * @author: exode <hello@exode.ru>
+ */
+export * from './types';
+export * from './api.service';
+export * from './analytics-service';
+export * from './project-service';
+export * from './video-service';

package/dist/index.js

@@ -0,0 +1,36 @@
+/**
+ * Index
+ *
+ * @author: exode <hello@exode.ru>
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./types", "./api.service", "./analytics-service", "./project-service", "./video-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./types"), exports);
+    __exportStar(require("./api.service"), exports);
+    __exportStar(require("./analytics-service"), exports);
+    __exportStar(require("./project-service"), exports);
+    __exportStar(require("./video-service"), exports);
+});

package/dist/project-service.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ProjectService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+import { BaseService } from './base-service';
+import { ProjectCreateRequest, ProjectCreateResponse, ProjectDeleteResponse, ProjectGetByIdRequest, ProjectGetByIdResponse, ProjectGetRequest, ProjectGetResponse, ProjectUpdateRequest, ProjectUpdateResponse } from './types';
+export declare class ProjectService extends BaseService {
+    /**
+     * Create a project
+     * @param {ProjectCreateRequest} data
+     * @returns {Promise<ProjectCreateResponse>}
+     */
+    create(data: ProjectCreateRequest): Promise<ProjectCreateResponse>;
+    /**
+     * Get many projects
+     * @param {ProjectGetRequest} params
+     * @returns {Promise<ProjectGetResponse>}
+     */
+    getMany(params: ProjectGetRequest): Promise<ProjectGetResponse>;
+    /**
+     * Get project by id
+     * @param {ProjectGetByIdRequest} params
+     * @returns {Promise<ProjectGetByIdResponse>}
+     */
+    getById(params: ProjectGetByIdRequest): Promise<ProjectGetByIdResponse>;
+    /**
+     * Update project by id
+     * @param {string} projectId
+     * @param {ProjectUpdateRequest} params
+     * @returns {Promise<ProjectUpdateResponse>}
+     */
+    updateById(projectId: string, params: ProjectUpdateRequest): Promise<ProjectUpdateResponse>;
+    /**
+     * Delete project by id
+     * @param {string} projectId
+     * @returns {Promise<ProjectDeleteResponse>}
+     */
+    deleteById(projectId: string): Promise<ProjectDeleteResponse>;
+}

package/dist/project-service.js

@@ -0,0 +1,114 @@
+/**
+ * ProjectService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./base-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProjectService = void 0;
+    const base_service_1 = require("./base-service");
+    class ProjectService extends base_service_1.BaseService {
+        /**
+         * Create a project
+         * @param {ProjectCreateRequest} data
+         * @returns {Promise<ProjectCreateResponse>}
+         */
+        create(data) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi('https://api.kinescope.io/v1/projects', data, 'post');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+        /**
+         * Get many projects
+         * @param {ProjectGetRequest} params
+         * @returns {Promise<ProjectGetResponse>}
+         */
+        getMany(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi('https://api.kinescope.io/v1/projects', params, 'get');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+        /**
+         * Get project by id
+         * @param {ProjectGetByIdRequest} params
+         * @returns {Promise<ProjectGetByIdResponse>}
+         */
+        getById(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi(`https://api.kinescope.io/v1/projects/${params.id}`, {}, 'get');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+        ;
+        /**
+         * Update project by id
+         * @param {string} projectId
+         * @param {ProjectUpdateRequest} params
+         * @returns {Promise<ProjectUpdateResponse>}
+         */
+        updateById(projectId, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi(`https://api.kinescope.io/v1/projects/${projectId}`, params, 'put');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+        ;
+        /**
+         * Delete project by id
+         * @param {string} projectId
+         * @returns {Promise<ProjectDeleteResponse>}
+         */
+        deleteById(projectId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi(`https://api.kinescope.io/v1/projects/${projectId}`, {}, 'delete');
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+    }
+    exports.ProjectService = ProjectService;
+});

package/dist/types/dto/analytics/analyticsGetCustom.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Analytics getMany custom
+ */
+
+export interface AnalyticsGetCustomRequest {
+    from: string;
+    to: string;
+    group: string;
+    group_entities: string;
+    fields: string[];
+    order?: string[];
+}
+
+export interface AnalyticsGetCustomResponse {
+    readonly meta: {
+        order: {
+            view: string;
+            play: string;
+        };
+        time: {
+            from: string;
+            to: string;
+            timezone: string;
+        };
+    };
+
+    readonly data: {
+        workspace_id: string;
+        video_id: string;
+        date: string;
+        view: number;
+        play: number;
+    }[];
+}
+

package/dist/types/dto/analytics/analyticsGetOverview.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Analytics getMany overview
+ */
+
+export interface AnalyticsGetOverviewRequest {
+    from: string;
+    to: string;
+    group_time: string;
+    video_id?: string;
+}
+
+export interface AnalyticsGetOverviewResponse {
+    readonly meta: {
+        time: {
+            from: string;
+            to: string;
+            timezone: string;
+        };
+    };
+
+    readonly data: {
+        total: {
+            views: number;
+            duration: number;
+            watch_time: number;
+            player_loads: number;
+        };
+
+        timeline: {
+            views: number;
+            duration: number;
+            watch_time: number;
+            player_loads: number;
+            date: string;
+        }[];
+
+        top: {
+            oses: {
+                name: string;
+                views: number;
+                player_loads: number;
+            }[];
+
+            devices: {
+                name: string;
+                views: number;
+                player_loads: number;
+            }[];
+
+            browsers: {
+                name: string;
+                views: number;
+                player_loads: number;
+            }[];
+
+            countries: {
+                name: string;
+                code: string;
+                views: number;
+                player_loads: number;
+            }[];
+        };
+    };
+}

package/dist/types/dto/project/projectCreate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Create project
+ */
+
+export interface ProjectCreateRequest {
+    name: string;
+    privacy_type: string;
+    privacy_domains: string[];
+    player_id?: string;
+    encrypted?: boolean;
+}
+
+export interface ProjectCreateResponse {
+    readonly id: string;
+    readonly name: string;
+    readonly folders: any[];
+    readonly privacy_type: string;
+    readonly privacy_domains: string[];
+    readonly player_id: string;
+    readonly favorite: boolean;
+    readonly size: number;
+    readonly items_count: number;
+    readonly created_at: string;
+    readonly updated_at: string | null;
+    readonly encrypted: boolean;
+}

package/dist/types/dto/project/projectDelete.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Delete project
+ */
+
+export interface ProjectDeleteResponse {
+    readonly projectId: string;
+}

package/dist/types/dto/project/projectGet.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Get project
+ */
+
+export interface ProjectGetRequest {
+    catalog_type?: string,
+    per_page?: number,
+    page?: number,
+}
+
+export interface ProjectGetResponse {
+    readonly meta: {
+        pagination: {
+            page: number;
+            per_page: number;
+            total: number;
+        };
+
+        order: {
+            name: string;
+        };
+    };
+
+    readonly data: {
+        id: string;
+        name: string;
+        created_at: string;
+        updated_at: string | null;
+
+        folders: {
+            id: string;
+            name: string;
+            project_id: string;
+            created_at: string;
+            updated_at: string | null;
+            deleted_at: string | null;
+        }[];
+    }[];
+}

package/dist/types/dto/project/projectGetById.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get a project by id
+ */
+
+export interface ProjectGetByIdRequest {
+    id: string;
+}
+
+export interface ProjectGetByIdResponse {
+    readonly id: string;
+    readonly name: string;
+    readonly created_at: string;
+    readonly updated_at: string | null;
+
+    folders: {
+        id: string;
+        name: string;
+        project_id: string;
+        created_at: string;
+        updated_at: string | null;
+        deleted_at: string | null;
+    }[];
+}

package/dist/types/dto/project/projectUpdateById.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Update project
+ */
+
+export interface ProjectUpdateRequest {
+    name: string;
+    privacy_type: string;
+    privacy_domains: string[];
+}
+
+export interface ProjectUpdateResponse {
+    readonly name: string;
+    readonly privacy_type: string;
+    readonly privacy_domains: string[];
+    readonly apply_to_videos: boolean;
+    readonly player_id: string;
+}

package/dist/types/dto/video/videoUpload.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Upload Video
+ */
+
+export interface VideoUploadHeadersByFile extends Record<string, string> {
+    'X-Parent-ID': string;
+    'X-Video-Title': string;
+    'X-Video-Trim': string;
+}
+
+export interface VideoUploadHeadersByUrl extends Record<string, string> {
+    'X-Parent-ID': string;
+    'X-Video-Title': string;
+    'X-Video-URL': string;
+}
+
+export interface VideoUploadResponse {
+    readonly data: boolean;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,63 @@
+// noinspection ES6PreferShortImport @note: for correct dist types
+
+/**
+ * Index
+ *
+ * @author: exode <hello@exode.ru>
+ */
+
+import { AnalyticsGetOverviewRequest, AnalyticsGetOverviewResponse } from './dto/analytics/analyticsGetOverview';
+import { AnalyticsGetCustomRequest, AnalyticsGetCustomResponse } from './dto/analytics/analyticsGetCustom';
+
+import { ProjectCreateRequest, ProjectCreateResponse } from './dto/project/projectCreate';
+import { ProjectGetRequest, ProjectGetResponse } from './dto/project/projectGet';
+import { ProjectGetByIdRequest, ProjectGetByIdResponse } from './dto/project/projectGetById';
+import { ProjectUpdateRequest, ProjectUpdateResponse } from './dto/project/projectUpdateById';
+import { ProjectDeleteResponse } from './dto/project/projectDelete';
+
+import { VideoUploadHeadersByFile, VideoUploadHeadersByUrl, VideoUploadResponse } from './dto/video/videoUpload';
+
+
+/**
+ * Types of request
+ */
+export type Request = AnalyticsGetOverviewRequest |
+    AnalyticsGetCustomRequest |
+    ProjectCreateRequest |
+    ProjectGetRequest |
+    ProjectGetByIdRequest |
+    ProjectUpdateRequest |
+    VideoUploadHeadersByFile |
+    VideoUploadHeadersByUrl;
+
+/**
+ * Types of response
+ */
+export type Response = AnalyticsGetOverviewResponse |
+    AnalyticsGetCustomResponse |
+    ProjectCreateResponse |
+    ProjectGetResponse |
+    ProjectGetByIdResponse |
+    ProjectUpdateResponse |
+    ProjectDeleteResponse |
+    VideoUploadResponse;
+
+export {
+    AnalyticsGetOverviewRequest,
+    AnalyticsGetCustomRequest,
+    ProjectCreateRequest,
+    ProjectGetRequest,
+    ProjectGetByIdRequest,
+    ProjectUpdateRequest,
+    VideoUploadHeadersByFile,
+    VideoUploadHeadersByUrl,
+    AnalyticsGetOverviewResponse,
+    AnalyticsGetCustomResponse,
+    ProjectCreateResponse,
+    ProjectGetResponse,
+    ProjectGetByIdResponse,
+    ProjectUpdateResponse,
+    ProjectDeleteResponse,
+    VideoUploadResponse,
+};
+

package/dist/video-service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * VideoService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+/// <reference types="node" />
+import { BaseService } from './base-service';
+import { VideoUploadHeadersByFile, VideoUploadHeadersByUrl, VideoUploadResponse } from './types';
+export declare class VideoService extends BaseService {
+    /**
+     * Upload video by file
+     * @param {File | Buffer} data
+     * @param {VideoUploadHeadersByFile} headers
+     * @returns {Promise<VideoUploadResponse>}
+     */
+    uploadVideoByFile(data: File | Buffer, headers: VideoUploadHeadersByFile): Promise<VideoUploadResponse>;
+    /**
+     * Upload video by url
+     * @param {VideoUploadHeadersByUrl} headers
+     * @returns {Promise<VideoUploadResponse>}
+     */
+    uploadVideoByUrl(headers: VideoUploadHeadersByUrl): Promise<VideoUploadResponse>;
+}

package/dist/video-service.js

@@ -0,0 +1,64 @@
+/**
+ * VideoService
+ *
+ * @author: exode <hello@exode.ru>
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./base-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VideoService = void 0;
+    const base_service_1 = require("./base-service");
+    class VideoService extends base_service_1.BaseService {
+        /**
+         * Upload video by file
+         * @param {File | Buffer} data
+         * @param {VideoUploadHeadersByFile} headers
+         * @returns {Promise<VideoUploadResponse>}
+         */
+        uploadVideoByFile(data, headers) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi('https://uploader.kinescope.io/v2/video', data, 'post', headers);
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+        /**
+         * Upload video by url
+         * @param {VideoUploadHeadersByUrl} headers
+         * @returns {Promise<VideoUploadResponse>}
+         */
+        uploadVideoByUrl(headers) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.requestApi('https://uploader.kinescope.io/v2/video', {}, 'post', headers);
+                }
+                catch (error) {
+                    console.error(`${error}`);
+                    throw error;
+                }
+            });
+        }
+    }
+    exports.VideoService = VideoService;
+});

package/env.example

@@ -0,0 +1,3 @@
+#Kinescope api token
+API_TOKEN=""
+

package/examples/api-test.ts

@@ -0,0 +1,131 @@
+/**
+ * Test api cases
+ */
+
+import fs from 'fs';
+import FormData from 'form-data';
+
+import { ApiService } from '../src/api.service';
+
+
+require('dotenv').config();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const createProject = await apiService.project.create({
+        name: 'Мой тестовый проект 2',
+        privacy_type: 'custom',
+        privacy_domains: [ 'exode.ru', 'staging.exode.ru' ],
+    });
+
+    console.log('createProject', createProject);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const getProject = await apiService.project.getMany({
+        per_page: 10,
+        page: 1,
+    });
+
+    console.log('getProject', getProject);
+
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const getProjectById = await apiService.project.getById({
+        id: 'f95f15f3-f826-4af1-8641-cf5f8ce83231',
+    });
+
+    console.log('getProjectById', getProjectById);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const updateProject = await apiService.project.updateById(
+        'f95f15f3-f826-4af1-8641-cf5f8ce83231',
+        {
+            name: 'new name of project',
+            privacy_type: 'custom',
+            privacy_domains: [ 'exode.ru', 'staging.exode.ru' ],
+        },
+    );
+
+    console.log('updateProject', updateProject);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const deleteProject = await apiService.project.deleteById(
+        'f95f15f3-f826-4af1-8641-cf5f8ce83231',
+    );
+
+    console.log('deleteProject', deleteProject);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const getOverview = await apiService.analytics.getOverview({
+        from: '2020-08-30',
+        to: '2020-09-01',
+        group_time: 'day',
+    });
+
+    console.log('getOverview', getOverview);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const getCustom = await apiService.analytics.getCustom({
+        from: '2020-11-01T06:00:00Z',
+        to: '2020-11-01T06:00:00Z',
+        group: 'day',
+        group_entities: 'video_id',
+        fields: [ 'view', 'play' ],
+    });
+
+    console.log('getCustom', getCustom);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+    const form = new FormData();
+
+    form.append('file', fs.createReadStream('test.mp4'), {
+        filename: 'test.mp4',
+        contentType: 'video/mp4',
+    });
+    const uploadVideo = await apiService.video.uploadVideoByFile(
+        fs.readFileSync('test.mp4'),
+        {
+            'X-Parent-ID': '92b93e72-27cc-49be-ac53-ca4a5f276f52',
+            'X-Video-Title': 'testOne',
+            'X-Video-Trim': JSON.stringify({ start: 1, length: 2 }),
+            ...form.getHeaders(),
+        },
+    );
+
+    console.log('uploadVideo', uploadVideo);
+})();
+
+(async () => {
+    const apiService = new ApiService(`${process.env.API_TOKEN}`);
+
+    const headers = {
+        'X-Parent-ID': '92b93e72-27cc-49be-ac53-ca4a5f276f52',
+        'X-Video-Title': 'testTwo',
+        'X-Video-URL': 'https://www.youtube.com/watch?v=qzbtdclsJXw',
+    };
+
+    const uploadVideo = await apiService.video.uploadVideoByUrl(headers);
+    console.log('uploadVideo', uploadVideo);
+
+})();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@exode-team/kinescope.api",
+  "version": "2.0.32",
+  "main": "index.js",
+  "author": "aslanorlov <aslanorlov@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "build": "yarn clean && tsc && yarn copy-definitions",
+    "build:watch": "yarn clean && tsc-watch",
+    "lint": "eslint -c ./.eslintrc.js ./src --ext .ts,.js --fix",
+    "lint:test": "eslint -c ./.eslintrc.js ./src --ext .ts,.js",
+    "clean": "rimraf dist",
+    "copy-definitions": "copyfiles -u 1 \"src/**/*.d.ts\" dist",
+    "test": "npx ts-node examples/api-test.ts",
+    "npm:publish": "npm run build && npm publish"
+  },
+  "dependencies": {
+    "axios": "^1.6.8",
+    "dotenv": "^16.4.5",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.3",
+    "@babel/preset-env": "^7.24.3",
+    "@babel/preset-typescript": "^7.24.1",
+    "@types/debug": "^4.1.12",
+    "@types/jest": "^29.5.12",
+    "@types/lodash": "^4.17.0",
+    "@types/node": "^20.11.30",
+    "babel-jest": "^29.7.0",
+    "copyfiles": "^2.4.1",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-watch": "^1.0.8",
+    "typescript": "^5.4.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,76 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
+    "module": "umd",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    "allowJs": true,                          /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": true,                      /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "./dist",                      /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",               /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    "baseUrl": ".",                           /* Base directory to resolve non-absolute module names. */
+
+    /**
+     * A series of entries which re-map imports to lookup locations relative to the 'baseUrl'.
+     */
+    "paths": {
+      "*": [
+        "./src/types/*"
+      ]
+    },
+
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+  },
+
+  "include": [
+    "./src/index.ts"
+  ]
+}