@internxt/sdk 1.4.76

package/dist/photos/devices/index.js

@@ -0,0 +1,79 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var utils_1 = require("../../utils");
+var DevicesSubmodule = /** @class */ (function () {
+    function DevicesSubmodule(model) {
+        this.model = model;
+    }
+    DevicesSubmodule.prototype.getDeviceById = function (deviceId) {
+        var _this = this;
+        return axios_1.default
+            .get(this.model.baseUrl + "/devices/" + deviceId, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return _this.parse(res.data); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    DevicesSubmodule.prototype.getDevices = function () {
+        var _this = this;
+        return axios_1.default
+            .get(this.model.baseUrl + "/devices", {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return res.data.results.map(function (json) { return _this.parse(json); }); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    DevicesSubmodule.prototype.createDevice = function (data) {
+        var _this = this;
+        return axios_1.default
+            .post(this.model.baseUrl + "/devices", data, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return _this.parse(res.data); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    DevicesSubmodule.prototype.deleteDevice = function (deviceId) {
+        return axios_1.default
+            .delete(this.model.baseUrl + "/devices/" + deviceId, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function () { return undefined; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    DevicesSubmodule.prototype.parse = function (json) {
+        return __assign(__assign({}, json), { newestDate: new Date(json.newestDate), oldestDate: json.oldestDate === null ? json.oldestDate : new Date(json.oldestDate), createdAt: new Date(json.createdAt), updatedAt: new Date(json.updatedAt) });
+    };
+    return DevicesSubmodule;
+}());
+exports.default = DevicesSubmodule;

package/dist/photos/index.d.ts

@@ -0,0 +1,17 @@
+import UsersSubmodule from './users';
+import DevicesSubmodule from './devices';
+import PhotosSubmodule from './photos';
+import SharesSubmodule from './shares';
+export declare class Photos {
+    private readonly model;
+    readonly users: UsersSubmodule;
+    readonly photos: PhotosSubmodule;
+    readonly devices: DevicesSubmodule;
+    readonly shares: SharesSubmodule;
+    constructor(baseUrl: string, accessToken?: string);
+    setBaseUrl(baseUrl: string): void;
+    setAccessToken(accessToken: string): void;
+    get baseUrl(): string | undefined;
+    get accessToken(): string | undefined;
+}
+export * from './types';

package/dist/photos/index.js

@@ -0,0 +1,52 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Photos = void 0;
+var users_1 = __importDefault(require("./users"));
+var devices_1 = __importDefault(require("./devices"));
+var photos_1 = __importDefault(require("./photos"));
+var shares_1 = __importDefault(require("./shares"));
+var Photos = /** @class */ (function () {
+    function Photos(baseUrl, accessToken) {
+        this.model = { baseUrl: baseUrl, accessToken: accessToken };
+        this.users = new users_1.default(this.model);
+        this.photos = new photos_1.default(this.model);
+        this.devices = new devices_1.default(this.model);
+        this.shares = new shares_1.default(this.model);
+    }
+    Photos.prototype.setBaseUrl = function (baseUrl) {
+        this.model.baseUrl = baseUrl;
+    };
+    Photos.prototype.setAccessToken = function (accessToken) {
+        this.model.accessToken = accessToken;
+    };
+    Object.defineProperty(Photos.prototype, "baseUrl", {
+        get: function () {
+            return this.model.baseUrl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Photos.prototype, "accessToken", {
+        get: function () {
+            return this.model.accessToken;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Photos;
+}());
+exports.Photos = Photos;
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,60 @@
+import { CreatePhotoData, Photo, PhotoId, PhotosSdkModel, PhotoStatus } from '..';
+import { PhotoWithDownloadLink, PhotoExistsPayload, PhotoExistsData, PhotosUsage, UpdatePhotoPayload, PhotosCount, PhotosSortBy } from '../types';
+export default class PhotosSubmodule {
+    private model;
+    constructor(model: PhotosSdkModel);
+    getPhotoById(photoId: PhotoId): Promise<Photo>;
+    getPhotosSorted(filter: {
+        status?: PhotoStatus;
+        updatedAt?: Date;
+    }, sort: {
+        sortBy: PhotosSortBy;
+        sortType: 'ASC' | 'DESC';
+    }, skip: number, limit: number, includeDownloadLinks: true): Promise<{
+        results: PhotoWithDownloadLink[];
+        bucketId: string;
+    }>;
+    getPhotosSorted(filter: {
+        status?: PhotoStatus;
+        updatedAt?: Date;
+    }, sort: {
+        sortBy: PhotosSortBy;
+        sortType: 'ASC' | 'DESC';
+    }, skip: number, limit: number, includeDownloadLinks: false): Promise<{
+        results: Photo[];
+        bucketId: string;
+    }>;
+    getPhotos(filter: {
+        name?: string;
+        status?: PhotoStatus;
+        updatedAt?: Date;
+    }, skip: number, limit: number): Promise<{
+        results: Photo[];
+        bucketId: string;
+    }>;
+    getPhotos(filter: {
+        name?: string;
+        status?: PhotoStatus;
+        updatedAt?: Date;
+    }, skip: number, limit: number, includeDownloadLinks: true): Promise<{
+        results: PhotoWithDownloadLink[];
+        bucketId: string;
+    }>;
+    createPhoto(data: CreatePhotoData): Promise<Photo>;
+    findOrCreatePhoto(data: CreatePhotoData): Promise<Photo>;
+    deletePhotosById(photos: {
+        id: PhotoId;
+    }[]): Promise<void>;
+    deletePhotoById(photoId: PhotoId): Promise<void>;
+    trashPhotosById(photos: {
+        id: PhotoId;
+    }[]): Promise<void>;
+    trashPhotoById(photoId: PhotoId): Promise<void>;
+    getUsage(): Promise<PhotosUsage>;
+    photosExists(photosExistPayload: PhotoExistsPayload[]): Promise<PhotoExistsData[]>;
+    updatePhoto(photoId: PhotoId, data: UpdatePhotoPayload): Promise<{
+        message: string;
+    }>;
+    getCount(): Promise<PhotosCount>;
+    private parse;
+}

package/dist/photos/photos/index.js

@@ -0,0 +1,225 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var query_string_1 = __importDefault(require("query-string"));
+var utils_1 = require("../../utils");
+var PhotosSubmodule = /** @class */ (function () {
+    function PhotosSubmodule(model) {
+        this.model = model;
+    }
+    PhotosSubmodule.prototype.getPhotoById = function (photoId) {
+        var _this = this;
+        return axios_1.default
+            .get(this.model.baseUrl + "/photos/" + photoId, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return _this.parse(res.data); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.getPhotosSorted = function (filter, sort, skip, limit, includeDownloadLinks) {
+        var _this = this;
+        var query = query_string_1.default.stringify(__assign(__assign(__assign(__assign({}, filter), { skip: skip, limit: limit }), sort), { includeDownloadLinks: includeDownloadLinks === true }));
+        if (skip < 0) {
+            throw new Error('Invalid skip. Skip should be positive. Provided skip was: ' + skip);
+        }
+        return axios_1.default
+            .get(this.model.baseUrl + "/photos/sorted?" + query, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return ({
+            results: res.data.results.map(function (photoJson) { return _this.parse(photoJson); }),
+            bucketId: res.data.bucketId,
+        }); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.getPhotos = function (filter, skip, limit, includeDownloadLinks) {
+        var _this = this;
+        if (skip === void 0) { skip = 0; }
+        if (limit === void 0) { limit = 1; }
+        var query = query_string_1.default.stringify(__assign(__assign({}, filter), { skip: skip, limit: limit, includeDownloadLinks: includeDownloadLinks }));
+        if (skip < 0) {
+            throw new Error('Invalid skip. Skip should be positive. Provided skip was: ' + skip);
+        }
+        return axios_1.default
+            .get(this.model.baseUrl + "/photos/?" + query, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return ({
+            results: res.data.results.map(function (photoJson) { return _this.parse(photoJson); }),
+            bucketId: res.data.bucketId,
+        }); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.createPhoto = function (data) {
+        var _this = this;
+        return axios_1.default
+            .post(this.model.baseUrl + "/photos", data, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return _this.parse(res.data); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.findOrCreatePhoto = function (data) {
+        var _this = this;
+        return axios_1.default
+            .post(this.model.baseUrl + "/photos/photo/exists", data, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) { return _this.parse(res.data); })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.deletePhotosById = function (photos) {
+        return axios_1.default
+            .delete(this.model.baseUrl + "/photos/photos", {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+            data: {
+                photos: photos,
+            },
+        })
+            .then(function () { return undefined; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.deletePhotoById = function (photoId) {
+        return axios_1.default
+            .delete(this.model.baseUrl + "/photos/" + photoId, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function () { return undefined; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.trashPhotosById = function (photos) {
+        return axios_1.default
+            .post(this.model.baseUrl + "/photos/photos/trash", {
+            photos: photos,
+        }, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function () { return undefined; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.trashPhotoById = function (photoId) {
+        return axios_1.default
+            .post(this.model.baseUrl + "/photos/" + photoId + "/trash", {}, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function () { return undefined; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.getUsage = function () {
+        return axios_1.default
+            .get(this.model.baseUrl + "/photos/usage", {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (result) {
+            return result.data;
+        })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.photosExists = function (photosExistPayload) {
+        var _this = this;
+        return axios_1.default
+            .post(this.model.baseUrl + "/photos/exists", { photos: photosExistPayload }, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (res) {
+            return res.data.photos.map(function (result) {
+                if ('id' in result) {
+                    return __assign(__assign({}, _this.parse(result)), { exists: true });
+                }
+                else {
+                    return __assign(__assign({}, result), { takenAt: new Date(result.takenAt) });
+                }
+            });
+        })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.updatePhoto = function (photoId, data) {
+        return axios_1.default
+            .patch(this.model.baseUrl + "/photos/" + photoId, data, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (result) {
+            return result.data;
+        })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.getCount = function () {
+        return axios_1.default
+            .get(this.model.baseUrl + "/photos/count", {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (result) { return result.data; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    PhotosSubmodule.prototype.parse = function (json) {
+        return __assign(__assign({}, json), { takenAt: new Date(json.takenAt), statusChangedAt: new Date(json.statusChangedAt), createdAt: new Date(json.createdAt), updatedAt: new Date(json.updatedAt) });
+    };
+    return PhotosSubmodule;
+}());
+exports.default = PhotosSubmodule;

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

@@ -0,0 +1,8 @@
+import { CreatePhotoShareBody, PhotosSdkModel } from '..';
+import { GetPhotoShareResponse, Share } from '../types';
+export default class SharesSubmodule {
+    private model;
+    constructor(model: PhotosSdkModel);
+    getShare(id: string, code: string): Promise<GetPhotoShareResponse>;
+    createShare(body: CreatePhotoShareBody): Promise<Share>;
+}

package/dist/photos/shares/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var utils_1 = require("../../utils");
+var SharesSubmodule = /** @class */ (function () {
+    function SharesSubmodule(model) {
+        this.model = model;
+    }
+    SharesSubmodule.prototype.getShare = function (id, code) {
+        return axios_1.default
+            .get(this.model.baseUrl + "/shares/" + id + "?code=" + code)
+            .then(function (response) { return response.data; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    SharesSubmodule.prototype.createShare = function (body) {
+        return axios_1.default
+            .post(this.model.baseUrl + "/shares", body, {
+            headers: {
+                Authorization: "Bearer " + this.model.accessToken,
+            },
+        })
+            .then(function (response) { return response.data; })
+            .catch(function (err) {
+            throw new Error((0, utils_1.extractAxiosErrorMessage)(err));
+        });
+    };
+    return SharesSubmodule;
+}());
+exports.default = SharesSubmodule;

package/dist/photos/types.d.ts

@@ -0,0 +1,154 @@
+export interface PhotosSdkModel {
+    baseUrl: string;
+    accessToken?: string;
+}
+export declare type UserId = string;
+export interface User {
+    id: UserId;
+    uuid: string;
+    bucketId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UserJSON extends Omit<User, 'createdAt' | 'updatedAt'> {
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InitializeUserData {
+    mac: string;
+    name: string;
+    bridgeUser: string;
+    bridgePassword: string;
+}
+export declare type DeviceId = string;
+export interface Device {
+    id: DeviceId;
+    mac: string;
+    name: string;
+    userId: string;
+    newestDate: Date;
+    oldestDate: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface DeviceJSON extends Omit<Device, 'newestDate' | 'oldestDate' | 'createdAt' | 'updatedAt'> {
+    newestDate: string;
+    oldestDate: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateDeviceData {
+    mac: string;
+    name: string;
+    userId: string;
+}
+export declare enum PhotoStatus {
+    Exists = "EXISTS",
+    Trashed = "TRASHED",
+    Deleted = "DELETED"
+}
+export declare enum PhotosSortBy {
+    UpdatedAt = "updatedAt",
+    TakenAt = "takenAt"
+}
+export declare type FileId = string;
+export declare type PhotoId = string;
+export declare type PhotoPreviewType = 'PNG' | 'JPEG';
+export declare enum PhotosItemType {
+    PHOTO = "PHOTO",
+    VIDEO = "VIDEO"
+}
+export interface Photo {
+    id: PhotoId;
+    name: string;
+    type: string;
+    size: number;
+    width: number;
+    height: number;
+    fileId: FileId;
+    previewId: FileId;
+    previews?: {
+        width: number;
+        height: number;
+        size: number;
+        fileId: FileId;
+        type: PhotoPreviewType;
+    }[];
+    deviceId: DeviceId;
+    userId: string;
+    status: PhotoStatus;
+    statusChangedAt: Date;
+    hash: string;
+    takenAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    duration?: number;
+    itemType: PhotosItemType;
+    networkBucketId?: string;
+}
+export interface UpdatePhotoPayload {
+    previews?: {
+        width: number;
+        height: number;
+        size: number;
+        fileId: FileId;
+        type: PhotoPreviewType;
+    }[];
+}
+export interface PhotoWithDownloadLink extends Photo {
+    previewLink: string;
+    previewIndex: string;
+}
+export interface PhotoJSON extends Omit<Photo, 'statusChangedAt' | 'takenAt' | 'createdAt' | 'updatedAt'> {
+    statusChangedAt: string;
+    takenAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare type CreatePhotoData = Omit<Photo, 'id' | 'status' | 'statusChangedAt' | 'createdAt' | 'updatedAt'> & {
+    networkBucketId: string;
+};
+export declare type ShareId = string;
+export interface Share {
+    id: ShareId;
+    bucket: string;
+    photoIds: PhotoId[];
+    token: string;
+    views: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ShareJSON extends Omit<Share, 'createdAt' | 'updatedAt'> {
+    createdAt: string;
+    updatedAt: string;
+}
+export declare type CreatePhotoShareBody = Pick<Share, 'views' | 'photoIds' | 'bucket' | 'token'> & {
+    encryptedMnemonic: string;
+};
+export declare type GetPhotoShareResponse = Share & {
+    photos: (Pick<Photo, 'fileId' | 'name' | 'size' | 'type'> & {
+        decryptionKey: string;
+    })[];
+};
+export declare type PhotoExistsPayload = {
+    hash: string;
+    name: string;
+    takenAt: string;
+};
+export declare type PhotoExistsDataJSON = (PhotoExistsPayload | PhotoJSON) & {
+    exists: boolean;
+};
+export declare type PhotoExistsData = ((Omit<PhotoExistsPayload, 'takenAt'> & {
+    takenAt: Date;
+}) | Photo) & {
+    exists: boolean;
+};
+export declare type PhotosUsage = {
+    usage: number;
+};
+export declare type PhotosCount = {
+    existent: number;
+    trashed: number;
+    deleted: number;
+    total: number;
+};

package/dist/photos/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhotosItemType = exports.PhotosSortBy = exports.PhotoStatus = void 0;
+var PhotoStatus;
+(function (PhotoStatus) {
+    PhotoStatus["Exists"] = "EXISTS";
+    PhotoStatus["Trashed"] = "TRASHED";
+    PhotoStatus["Deleted"] = "DELETED";
+})(PhotoStatus = exports.PhotoStatus || (exports.PhotoStatus = {}));
+var PhotosSortBy;
+(function (PhotosSortBy) {
+    PhotosSortBy["UpdatedAt"] = "updatedAt";
+    PhotosSortBy["TakenAt"] = "takenAt";
+})(PhotosSortBy = exports.PhotosSortBy || (exports.PhotosSortBy = {}));
+var PhotosItemType;
+(function (PhotosItemType) {
+    PhotosItemType["PHOTO"] = "PHOTO";
+    PhotosItemType["VIDEO"] = "VIDEO";
+})(PhotosItemType = exports.PhotosItemType || (exports.PhotosItemType = {}));

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

@@ -0,0 +1,7 @@
+import { InitializeUserData, PhotosSdkModel, User } from '..';
+export default class UsersSubmodule {
+    private model;
+    constructor(model: PhotosSdkModel);
+    initialize(data: InitializeUserData): Promise<User>;
+    private parse;
+}