@internxt/sdk 1.4.76

package/dist/network/index.d.ts

@@ -0,0 +1,71 @@
+import { BridgeUrl, StartUploadResponse, FinishUploadResponse, GetDownloadLinksResponse, NetworkRequestConfig, FinishUploadPayload, FinishMultipartUploadPayload } from './types';
+import { AppDetails } from '../shared';
+import { BasicAuth } from '../auth/types';
+import { StartUploadPayload } from './types';
+export * from './types';
+export declare class DuplicatedIndexesError extends Error {
+    constructor();
+}
+export declare class InvalidFileIndexError extends Error {
+    constructor();
+}
+export declare class InvalidUploadIndexError extends Error {
+    constructor();
+}
+export declare class InvalidUploadSizeError extends Error {
+    constructor();
+}
+export declare class FileTooSmallForMultipartError extends Error {
+    constructor();
+}
+export declare class InvalidMultipartValueError extends Error {
+    constructor();
+}
+export declare class Network {
+    private readonly client;
+    private readonly appDetails;
+    private readonly auth;
+    static client(apiUrl: BridgeUrl, appDetails: AppDetails, opts: {
+        bridgeUser: string;
+        userId: string;
+    }): Network;
+    private constructor();
+    get credentials(): BasicAuth;
+    startUpload(bucketId: string, payload: StartUploadPayload, parts?: number): Promise<StartUploadResponse>;
+    finishUpload(bucketId: string, payload: FinishUploadPayload): Promise<FinishUploadResponse>;
+    finishMultipartUpload(bucketId: string, payload: FinishMultipartUploadPayload): Promise<FinishUploadResponse>;
+    getDownloadLinks(bucketId: string, fileId: string, token?: string): Promise<GetDownloadLinksResponse>;
+    deleteFile(bucketId: string, fileId: string): Promise<void>;
+    /**
+     * Creates entries for every upload in the request, returns the urls to upload
+     * @param bucketId
+     * @param uploads
+     */
+    static startUpload(bucketId: string, payload: StartUploadPayload, { client, appDetails, auth }: NetworkRequestConfig, parts?: number): Promise<StartUploadResponse>;
+    /**
+     * Finishes the upload of a file
+     * @param bucketId
+     * @param index
+     * @param shards
+     */
+    private static finishUpload;
+    /**
+     * Gets the download links for a file
+     * @param bucketId
+     * @param file
+     */
+    private static getDownloadLinks;
+    /**
+     * Deletes a file
+     * @param bucketId
+     * @param file
+     */
+    private static deleteFile;
+    /**
+     * Gets headers with basic auth
+     * @param appDetails
+     * @param auth
+     */
+    private static headersWithBasicAuth;
+    private static headersWithAuthToken;
+}

package/dist/network/index.js

@@ -0,0 +1,310 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Network = exports.InvalidMultipartValueError = exports.FileTooSmallForMultipartError = exports.InvalidUploadSizeError = exports.InvalidUploadIndexError = exports.InvalidFileIndexError = exports.DuplicatedIndexesError = void 0;
+var uuid_1 = require("uuid");
+var client_1 = require("../shared/http/client");
+var index_1 = require("../shared/headers/index");
+var utils_1 = require("../utils");
+__exportStar(require("./types"), exports);
+var DuplicatedIndexesError = /** @class */ (function (_super) {
+    __extends(DuplicatedIndexesError, _super);
+    function DuplicatedIndexesError() {
+        var _this = _super.call(this, 'Duplicated indexes found') || this;
+        Object.setPrototypeOf(_this, DuplicatedIndexesError.prototype);
+        return _this;
+    }
+    return DuplicatedIndexesError;
+}(Error));
+exports.DuplicatedIndexesError = DuplicatedIndexesError;
+var InvalidFileIndexError = /** @class */ (function (_super) {
+    __extends(InvalidFileIndexError, _super);
+    function InvalidFileIndexError() {
+        var _this = _super.call(this, 'Invalid file index') || this;
+        Object.setPrototypeOf(_this, InvalidFileIndexError.prototype);
+        return _this;
+    }
+    return InvalidFileIndexError;
+}(Error));
+exports.InvalidFileIndexError = InvalidFileIndexError;
+var InvalidUploadIndexError = /** @class */ (function (_super) {
+    __extends(InvalidUploadIndexError, _super);
+    function InvalidUploadIndexError() {
+        var _this = _super.call(this, 'Invalid upload index') || this;
+        Object.setPrototypeOf(_this, InvalidUploadIndexError.prototype);
+        return _this;
+    }
+    return InvalidUploadIndexError;
+}(Error));
+exports.InvalidUploadIndexError = InvalidUploadIndexError;
+var InvalidUploadSizeError = /** @class */ (function (_super) {
+    __extends(InvalidUploadSizeError, _super);
+    function InvalidUploadSizeError() {
+        var _this = _super.call(this, 'Invalid size') || this;
+        Object.setPrototypeOf(_this, InvalidUploadSizeError.prototype);
+        return _this;
+    }
+    return InvalidUploadSizeError;
+}(Error));
+exports.InvalidUploadSizeError = InvalidUploadSizeError;
+var FileTooSmallForMultipartError = /** @class */ (function (_super) {
+    __extends(FileTooSmallForMultipartError, _super);
+    function FileTooSmallForMultipartError() {
+        var _this = _super.call(this, 'File is too small for multipart upload') || this;
+        Object.setPrototypeOf(_this, FileTooSmallForMultipartError.prototype);
+        return _this;
+    }
+    return FileTooSmallForMultipartError;
+}(Error));
+exports.FileTooSmallForMultipartError = FileTooSmallForMultipartError;
+var InvalidMultipartValueError = /** @class */ (function (_super) {
+    __extends(InvalidMultipartValueError, _super);
+    function InvalidMultipartValueError() {
+        var _this = _super.call(this, 'Invalid multipart value') || this;
+        Object.setPrototypeOf(_this, InvalidMultipartValueError.prototype);
+        return _this;
+    }
+    return InvalidMultipartValueError;
+}(Error));
+exports.InvalidMultipartValueError = InvalidMultipartValueError;
+var Network = /** @class */ (function () {
+    function Network(apiUrl, appDetails, opts) {
+        this.client = client_1.HttpClient.create(apiUrl);
+        this.appDetails = appDetails;
+        this.auth = {
+            username: opts.bridgeUser,
+            password: opts.userId,
+        };
+    }
+    Network.client = function (apiUrl, appDetails, opts) {
+        return new Network(apiUrl, appDetails, opts);
+    };
+    Object.defineProperty(Network.prototype, "credentials", {
+        get: function () {
+            return this.auth;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Network.prototype.startUpload = function (bucketId, payload, parts) {
+        if (parts === void 0) { parts = 1; }
+        var totalSize = 0;
+        for (var _i = 0, _a = payload.uploads; _i < _a.length; _i++) {
+            var _b = _a[_i], index = _b.index, size = _b.size;
+            if (index < 0) {
+                throw new InvalidUploadIndexError();
+            }
+            if (size < 0) {
+                throw new InvalidUploadSizeError();
+            }
+            totalSize += size;
+        }
+        var MB100 = 100 * 1024 * 1024;
+        if (totalSize < MB100 && parts > 1) {
+            throw new FileTooSmallForMultipartError();
+        }
+        if (!Number.isInteger(parts) || parts < 1) {
+            throw new InvalidMultipartValueError();
+        }
+        var uploadIndexesWithoutDuplicates = new Set(payload.uploads.map(function (upload) { return upload.index; }));
+        if (uploadIndexesWithoutDuplicates.size < payload.uploads.length) {
+            throw new DuplicatedIndexesError();
+        }
+        return Network.startUpload(bucketId, payload, {
+            client: this.client,
+            appDetails: this.appDetails,
+            auth: this.auth,
+        }, parts);
+    };
+    Network.prototype.finishUpload = function (bucketId, payload) {
+        var index = payload.index, shards = payload.shards;
+        if (!(0, utils_1.isHexString)(index) || index.length !== 64) {
+            throw new InvalidFileIndexError();
+        }
+        for (var _i = 0, shards_1 = shards; _i < shards_1.length; _i++) {
+            var shard = shards_1[_i];
+            if (!(0, uuid_1.validate)(shard.uuid)) {
+                throw new Error('Invalid UUID');
+            }
+        }
+        return Network.finishUpload(bucketId, payload, {
+            client: this.client,
+            appDetails: this.appDetails,
+            auth: this.auth,
+        });
+    };
+    Network.prototype.finishMultipartUpload = function (bucketId, payload) {
+        var index = payload.index, shards = payload.shards;
+        if (!(0, utils_1.isHexString)(index) || index.length !== 64) {
+            throw new InvalidFileIndexError();
+        }
+        for (var _i = 0, shards_2 = shards; _i < shards_2.length; _i++) {
+            var shard = shards_2[_i];
+            if (!(0, uuid_1.validate)(shard.uuid)) {
+                throw new Error('Invalid UUID');
+            }
+            if (!shard.UploadId) {
+                throw new Error('Missing UploadId');
+            }
+            if (!shard.parts) {
+                throw new Error('Missing parts');
+            }
+        }
+        return Network.finishUpload(bucketId, payload, {
+            client: this.client,
+            appDetails: this.appDetails,
+            auth: this.auth,
+        });
+    };
+    Network.prototype.getDownloadLinks = function (bucketId, fileId, token) {
+        return Network.getDownloadLinks(bucketId, fileId, {
+            client: this.client,
+            appDetails: this.appDetails,
+            auth: this.auth,
+        }, token);
+    };
+    Network.prototype.deleteFile = function (bucketId, fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Network.deleteFile(bucketId, fileId, {
+                            client: this.client,
+                            appDetails: this.appDetails,
+                            auth: this.auth,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates entries for every upload in the request, returns the urls to upload
+     * @param bucketId
+     * @param uploads
+     */
+    Network.startUpload = function (bucketId, payload, _a, parts) {
+        var client = _a.client, appDetails = _a.appDetails, auth = _a.auth;
+        if (parts === void 0) { parts = 1; }
+        var headers = Network.headersWithBasicAuth(appDetails, auth);
+        return client.post("/v2/buckets/" + bucketId + "/files/start?multiparts=" + parts, payload, headers);
+    };
+    /**
+     * Finishes the upload of a file
+     * @param bucketId
+     * @param index
+     * @param shards
+     */
+    Network.finishUpload = function (bucketId, payload, _a) {
+        var client = _a.client, appDetails = _a.appDetails, auth = _a.auth;
+        var headers = Network.headersWithBasicAuth(appDetails, auth);
+        return client.post("/v2/buckets/" + bucketId + "/files/finish", payload, headers);
+    };
+    /**
+     * Gets the download links for a file
+     * @param bucketId
+     * @param file
+     */
+    Network.getDownloadLinks = function (bucketId, fileId, _a, token) {
+        var client = _a.client, appDetails = _a.appDetails, auth = _a.auth;
+        var headers = token
+            ? Network.headersWithAuthToken(appDetails, token)
+            : Network.headersWithBasicAuth(appDetails, auth);
+        return client.get("/buckets/" + bucketId + "/files/" + fileId + "/info", __assign(__assign({}, headers), { 'x-api-version': '2' }));
+    };
+    /**
+     * Deletes a file
+     * @param bucketId
+     * @param file
+     */
+    Network.deleteFile = function (bucketId, fileId, _a) {
+        var client = _a.client, appDetails = _a.appDetails, auth = _a.auth;
+        var headers = Network.headersWithBasicAuth(appDetails, auth);
+        return client.delete("/v2/buckets/" + bucketId + "/files/" + fileId, headers);
+    };
+    /**
+     * Gets headers with basic auth
+     * @param appDetails
+     * @param auth
+     */
+    Network.headersWithBasicAuth = function (appDetails, auth) {
+        return (0, index_1.headersWithBasicAuth)(appDetails.clientName, appDetails.clientVersion, auth);
+    };
+    Network.headersWithAuthToken = function (appDetails, token) {
+        return (0, index_1.headersWithAuthToken)(appDetails.clientName, appDetails.clientVersion, token);
+    };
+    return Network;
+}());
+exports.Network = Network;

package/dist/network/types.d.ts

@@ -0,0 +1,102 @@
+import { AppDetails } from '../shared';
+import { HttpClient } from '../shared/http/client';
+import { BasicAuth } from '../auth/types';
+declare type Hash = string;
+export declare type BridgeUrl = string;
+export interface Shard {
+    uuid: string;
+    hash: Hash;
+}
+export interface ShardForMultipart extends Shard {
+    UploadId: string;
+    parts: {
+        PartNumber: number;
+        ETag: string;
+    }[];
+}
+export interface StartUploadResponse {
+    uploads: {
+        index: number;
+        uuid: Shard['uuid'];
+        url: string | null;
+        urls: string[] | null;
+        UploadId?: string;
+    }[];
+}
+export declare type FinishUploadResponse = BucketEntry;
+export interface BucketEntry {
+    id: string;
+    index: string;
+    bucket: string;
+    name: string;
+    mimetype: string;
+    created: Date;
+}
+export interface DownloadableShard {
+    index: number;
+    size: number;
+    hash: Shard['hash'];
+    url: string;
+}
+export interface GetDownloadLinksResponse {
+    bucket: string;
+    index: string;
+    created: Date;
+    shards: DownloadableShard[];
+    version?: number;
+    size: number;
+}
+export interface NetworkRequestConfig {
+    client: HttpClient;
+    appDetails: AppDetails;
+    auth: BasicAuth;
+}
+declare type UploadPayload = {
+    index: number;
+    size: number;
+};
+export declare type StartUploadPayload = {
+    uploads: UploadPayload[];
+};
+export declare type FinishUploadPayload = {
+    index: string;
+    shards: Shard[];
+};
+export declare type FinishMultipartUploadPayload = {
+    index: string;
+    shards: ShardForMultipart[];
+};
+export declare type UploadFileFunction = (url: string) => Promise<Hash>;
+export declare type UploadFileMultipartFunction = (urls: string[]) => Promise<{
+    hash: Hash;
+    parts: {
+        PartNumber: number;
+        ETag: string;
+    }[];
+}>;
+export declare type DownloadFileFunction = (downloadables: DownloadableShard[], fileSize: number) => Promise<void>;
+export declare type BinaryData = {
+    slice: (from: number, to: number) => BinaryData;
+    toString(encoding: 'hex'): string;
+};
+export declare enum BinaryDataEncoding {
+    HEX = "hex"
+}
+export declare type ToBinaryDataFunction = (input: string, encoding: BinaryDataEncoding) => BinaryData;
+export declare enum SymmetricCryptoAlgorithm {
+    AES256CTR = "AES256CTR"
+}
+export declare type Algorithm = {
+    type: SymmetricCryptoAlgorithm;
+    ivSize: number;
+};
+export declare const ALGORITHMS: Record<SymmetricCryptoAlgorithm, Algorithm>;
+export declare type Crypto = {
+    algorithm: Algorithm;
+    validateMnemonic: (mnemonic: string) => boolean;
+    randomBytes: (bytesLength: number) => BinaryData;
+    generateFileKey: (mnemonic: string, bucketId: string, index: BinaryData | string) => Promise<BinaryData>;
+};
+export declare type EncryptFileFunction = (algorithm: SymmetricCryptoAlgorithm, key: BinaryData, iv: BinaryData) => Promise<void>;
+export declare type DecryptFileFunction = (algorithm: SymmetricCryptoAlgorithm, key: BinaryData, iv: BinaryData, fileSize: number) => Promise<void>;
+export {};

package/dist/network/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALGORITHMS = exports.SymmetricCryptoAlgorithm = exports.BinaryDataEncoding = void 0;
+var BinaryDataEncoding;
+(function (BinaryDataEncoding) {
+    BinaryDataEncoding["HEX"] = "hex";
+})(BinaryDataEncoding = exports.BinaryDataEncoding || (exports.BinaryDataEncoding = {}));
+var SymmetricCryptoAlgorithm;
+(function (SymmetricCryptoAlgorithm) {
+    SymmetricCryptoAlgorithm["AES256CTR"] = "AES256CTR";
+})(SymmetricCryptoAlgorithm = exports.SymmetricCryptoAlgorithm || (exports.SymmetricCryptoAlgorithm = {}));
+exports.ALGORITHMS = (_a = {},
+    _a[SymmetricCryptoAlgorithm.AES256CTR] = {
+        type: SymmetricCryptoAlgorithm.AES256CTR,
+        ivSize: 32
+    },
+    _a);

package/dist/network/upload.d.ts

@@ -0,0 +1,4 @@
+import { Network } from '.';
+import { Crypto, EncryptFileFunction, UploadFileFunction, UploadFileMultipartFunction } from './types';
+export declare function uploadFile(network: Network, crypto: Crypto, bucketId: string, mnemonic: string, fileSize: number, encryptFile: EncryptFileFunction, uploadFile: UploadFileFunction): Promise<string>;
+export declare function uploadMultipartFile(network: Network, crypto: Crypto, bucketId: string, mnemonic: string, fileSize: number, encryptFile: EncryptFileFunction, uploadMultiparts: UploadFileMultipartFunction, parts?: number): Promise<string>;

package/dist/network/upload.js

@@ -0,0 +1,159 @@
+"use strict";
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMultipartFile = exports.uploadFile = void 0;
+var errors_1 = require("./errors");
+function uploadFile(network, crypto, bucketId, mnemonic, fileSize, encryptFile, uploadFile) {
+    return __awaiter(this, void 0, void 0, function () {
+        var index, iv, key, mnemonicIsValid, uploads, _a, url, uuid, hash, finishUploadPayload, finishUploadResponse, err_1, context;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, , 7]);
+                    mnemonicIsValid = crypto.validateMnemonic(mnemonic);
+                    if (!mnemonicIsValid) {
+                        throw new errors_1.UploadInvalidMnemonicError();
+                    }
+                    index = crypto.randomBytes(crypto.algorithm.ivSize);
+                    iv = index.slice(0, 16);
+                    return [4 /*yield*/, crypto.generateFileKey(mnemonic, bucketId, index)];
+                case 1:
+                    key = _b.sent();
+                    return [4 /*yield*/, network.startUpload(bucketId, {
+                            uploads: [{
+                                    index: 0,
+                                    size: fileSize
+                                }]
+                        })];
+                case 2:
+                    uploads = (_b.sent()).uploads;
+                    _a = uploads[0], url = _a.url, uuid = _a.uuid;
+                    if (!url) {
+                        throw new errors_1.UrlNotReceivedFromNetworkError();
+                    }
+                    return [4 /*yield*/, encryptFile(crypto.algorithm.type, key, iv)];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, uploadFile(url)];
+                case 4:
+                    hash = _b.sent();
+                    finishUploadPayload = {
+                        index: index.toString('hex'),
+                        shards: [{ hash: hash, uuid: uuid }]
+                    };
+                    return [4 /*yield*/, network.finishUpload(bucketId, finishUploadPayload)];
+                case 5:
+                    finishUploadResponse = _b.sent();
+                    return [2 /*return*/, finishUploadResponse.id];
+                case 6:
+                    err_1 = _b.sent();
+                    context = (0, errors_1.getNetworkErrorContext)({
+                        bucketId: bucketId,
+                        fileSize: fileSize,
+                        user: network.credentials.username,
+                        pass: network.credentials.password,
+                        crypto: {
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            index: index ? index.toString('hex') : 'none',
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            iv: iv ? iv.toString('hex') : 'none',
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            key: key ? key.toString('hex') : 'none',
+                            mnemonic: mnemonic
+                        }
+                    }, err_1);
+                    err_1.context = context;
+                    throw err_1;
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.uploadFile = uploadFile;
+function uploadMultipartFile(network, crypto, bucketId, mnemonic, fileSize, encryptFile, uploadMultiparts, parts) {
+    if (parts === void 0) { parts = 1; }
+    return __awaiter(this, void 0, void 0, function () {
+        var mnemonicIsValid, index, iv, key, uploads, _a, urls, uuid, UploadId, _b, hash, uploadedPartsReference, finishUploadPayload, finishUploadResponse;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    mnemonicIsValid = crypto.validateMnemonic(mnemonic);
+                    if (!mnemonicIsValid) {
+                        throw new errors_1.UploadInvalidMnemonicError();
+                    }
+                    index = crypto.randomBytes(crypto.algorithm.ivSize);
+                    iv = index.slice(0, 16);
+                    return [4 /*yield*/, crypto.generateFileKey(mnemonic, bucketId, index)];
+                case 1:
+                    key = _c.sent();
+                    return [4 /*yield*/, network.startUpload(bucketId, {
+                            uploads: [
+                                {
+                                    index: 0,
+                                    size: fileSize,
+                                },
+                            ],
+                        }, parts)];
+                case 2:
+                    uploads = (_c.sent()).uploads;
+                    _a = uploads[0], urls = _a.urls, uuid = _a.uuid, UploadId = _a.UploadId;
+                    if (!urls) {
+                        throw new errors_1.UrlsNotReceivedFromNetworkError();
+                    }
+                    if (!UploadId) {
+                        throw new errors_1.UploadIdNotReceivedFromNetworkError();
+                    }
+                    return [4 /*yield*/, encryptFile(crypto.algorithm.type, key, iv)];
+                case 3:
+                    _c.sent();
+                    return [4 /*yield*/, uploadMultiparts(urls)];
+                case 4:
+                    _b = _c.sent(), hash = _b.hash, uploadedPartsReference = _b.parts;
+                    finishUploadPayload = {
+                        index: index.toString('hex'),
+                        shards: [{ hash: hash, uuid: uuid, UploadId: UploadId, parts: uploadedPartsReference }],
+                    };
+                    return [4 /*yield*/, network.finishUpload(bucketId, finishUploadPayload)];
+                case 5:
+                    finishUploadResponse = _c.sent();
+                    return [2 /*return*/, finishUploadResponse.id];
+            }
+        });
+    });
+}
+exports.uploadMultipartFile = uploadMultipartFile;

package/dist/photos/devices/index.d.ts

@@ -0,0 +1,10 @@
+import { CreateDeviceData, Device, DeviceId, PhotosSdkModel } from '..';
+export default class DevicesSubmodule {
+    private model;
+    constructor(model: PhotosSdkModel);
+    getDeviceById(deviceId: DeviceId): Promise<Device>;
+    getDevices(): Promise<Device[]>;
+    createDevice(data: CreateDeviceData): Promise<Device>;
+    deleteDevice(deviceId: DeviceId): Promise<void>;
+    private parse;
+}