groupdocs-annotation-cloud/lib/model.js

GroupDocs.Annotation Cloud SDK for Node.js

"use strict";
/*
* The MIT License (MIT)
*
* Copyright (c) Aspose Pty Ltd
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetDiscUsageRequest = exports.GetPagesRequest = exports.DeletePagesRequest = exports.GetInfoRequest = exports.MoveFolderRequest = exports.GetFilesListRequest = exports.DeleteFolderRequest = exports.CreateFolderRequest = exports.CopyFolderRequest = exports.UploadFileRequest = exports.MoveFileRequest = exports.DownloadFileRequest = exports.DeleteFileRequest = exports.CopyFileRequest = exports.RemoveAnnotationsRequest = exports.ExtractRequest = exports.AnnotateDirectRequest = exports.AnnotateRequest = exports.typeMap = exports.enumsMap = exports.PageImage = exports.FileVersion = exports.AnnotationApiLink = exports.StorageFile = exports.StorageExist = exports.RemoveOptions = exports.Rectangle = exports.PreviewOptions = exports.Point = exports.PageInfo = exports.PageImages = exports.ObjectExist = exports.ModelError = exports.LinkElement = exports.Link = exports.FormatsResult = exports.Format = exports.FilesUploadResult = exports.FilesList = exports.FileVersions = exports.FileInfo = exports.ErrorDetails = exports.DocumentInfo = exports.DiscUsage = exports.ConsumptionResult = exports.ApiErrorResponse = exports.ApiError = exports.AnnotationReplyInfo = exports.AnnotationInfo = exports.AnnotateOptions = void 0;
exports.StorageExistsRequest = exports.ObjectExistsRequest = exports.GetFileVersionsRequest = void 0;
/**
 * Defines options for annotating documents
 */
class AnnotateOptions {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return AnnotateOptions.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.AnnotateOptions = AnnotateOptions;
/**
 * Attribute type map
 */
AnnotateOptions.attributeTypeMap = [
    {
        name: "fileInfo",
        baseName: "fileInfo",
        type: "FileInfo",
    },
    {
        name: "annotations",
        baseName: "annotations",
        type: "Array<AnnotationInfo>",
    },
    {
        name: "firstPage",
        baseName: "firstPage",
        type: "number",
    },
    {
        name: "lastPage",
        baseName: "lastPage",
        type: "number",
    },
    {
        name: "onlyAnnotatedPages",
        baseName: "onlyAnnotatedPages",
        type: "boolean",
    },
    {
        name: "outputPath",
        baseName: "outputPath",
        type: "string",
    },
    {
        name: "fontsPath",
        baseName: "fontsPath",
        type: "string",
    }
];
/**
 * Describes annotation properties
 */
class AnnotationInfo {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return AnnotationInfo.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.AnnotationInfo = AnnotationInfo;
/**
 * Attribute type map
 */
AnnotationInfo.attributeTypeMap = [
    {
        name: "id",
        baseName: "id",
        type: "number",
    },
    {
        name: "text",
        baseName: "text",
        type: "string",
    },
    {
        name: "textToReplace",
        baseName: "textToReplace",
        type: "string",
    },
    {
        name: "horizontalAlignment",
        baseName: "horizontalAlignment",
        type: "AnnotationInfo.HorizontalAlignmentEnum",
    },
    {
        name: "verticalAlignment",
        baseName: "verticalAlignment",
        type: "AnnotationInfo.VerticalAlignmentEnum",
    },
    {
        name: "creatorId",
        baseName: "creatorId",
        type: "number",
    },
    {
        name: "creatorName",
        baseName: "creatorName",
        type: "string",
    },
    {
        name: "creatorEmail",
        baseName: "creatorEmail",
        type: "string",
    },
    {
        name: "box",
        baseName: "box",
        type: "Rectangle",
    },
    {
        name: "points",
        baseName: "points",
        type: "Array<Point>",
    },
    {
        name: "pageNumber",
        baseName: "pageNumber",
        type: "number",
    },
    {
        name: "annotationPosition",
        baseName: "annotationPosition",
        type: "Point",
    },
    {
        name: "svgPath",
        baseName: "svgPath",
        type: "string",
    },
    {
        name: "type",
        baseName: "type",
        type: "AnnotationInfo.TypeEnum",
    },
    {
        name: "replies",
        baseName: "replies",
        type: "Array<AnnotationReplyInfo>",
    },
    {
        name: "createdOn",
        baseName: "createdOn",
        type: "Date",
    },
    {
        name: "fontColor",
        baseName: "fontColor",
        type: "number",
    },
    {
        name: "penColor",
        baseName: "penColor",
        type: "number",
    },
    {
        name: "penWidth",
        baseName: "penWidth",
        type: "number",
    },
    {
        name: "penStyle",
        baseName: "penStyle",
        type: "AnnotationInfo.PenStyleEnum",
    },
    {
        name: "backgroundColor",
        baseName: "backgroundColor",
        type: "number",
    },
    {
        name: "squigglyColor",
        baseName: "squigglyColor",
        type: "number",
    },
    {
        name: "fontFamily",
        baseName: "fontFamily",
        type: "string",
    },
    {
        name: "fontSize",
        baseName: "fontSize",
        type: "number",
    },
    {
        name: "opacity",
        baseName: "opacity",
        type: "number",
    },
    {
        name: "angle",
        baseName: "angle",
        type: "number",
    },
    {
        name: "zIndex",
        baseName: "zIndex",
        type: "number",
    },
    {
        name: "url",
        baseName: "url",
        type: "string",
    },
    {
        name: "imagePath",
        baseName: "imagePath",
        type: "string",
    },
    {
        name: "autoScale",
        baseName: "autoScale",
        type: "boolean",
    }
];
// tslint:disable:quotemark
// tslint:disable-next-line:no-namespace
(function (AnnotationInfo) {
    let HorizontalAlignmentEnum;
    (function (HorizontalAlignmentEnum) {
        HorizontalAlignmentEnum[HorizontalAlignmentEnum["None"] = 'None'] = "None";
        HorizontalAlignmentEnum[HorizontalAlignmentEnum["Left"] = 'Left'] = "Left";
        HorizontalAlignmentEnum[HorizontalAlignmentEnum["Center"] = 'Center'] = "Center";
        HorizontalAlignmentEnum[HorizontalAlignmentEnum["Right"] = 'Right'] = "Right";
    })(HorizontalAlignmentEnum = AnnotationInfo.HorizontalAlignmentEnum || (AnnotationInfo.HorizontalAlignmentEnum = {}));
    let VerticalAlignmentEnum;
    (function (VerticalAlignmentEnum) {
        VerticalAlignmentEnum[VerticalAlignmentEnum["None"] = 'None'] = "None";
        VerticalAlignmentEnum[VerticalAlignmentEnum["Top"] = 'Top'] = "Top";
        VerticalAlignmentEnum[VerticalAlignmentEnum["Center"] = 'Center'] = "Center";
        VerticalAlignmentEnum[VerticalAlignmentEnum["Bottom"] = 'Bottom'] = "Bottom";
    })(VerticalAlignmentEnum = AnnotationInfo.VerticalAlignmentEnum || (AnnotationInfo.VerticalAlignmentEnum = {}));
    let TypeEnum;
    (function (TypeEnum) {
        TypeEnum[TypeEnum["None"] = 'None'] = "None";
        TypeEnum[TypeEnum["Area"] = 'Area'] = "Area";
        TypeEnum[TypeEnum["Arrow"] = 'Arrow'] = "Arrow";
        TypeEnum[TypeEnum["Distance"] = 'Distance'] = "Distance";
        TypeEnum[TypeEnum["Ellipse"] = 'Ellipse'] = "Ellipse";
        TypeEnum[TypeEnum["Link"] = 'Link'] = "Link";
        TypeEnum[TypeEnum["Point"] = 'Point'] = "Point";
        TypeEnum[TypeEnum["Polyline"] = 'Polyline'] = "Polyline";
        TypeEnum[TypeEnum["ResourcesRedaction"] = 'ResourcesRedaction'] = "ResourcesRedaction";
        TypeEnum[TypeEnum["TextField"] = 'TextField'] = "TextField";
        TypeEnum[TypeEnum["TextHighlight"] = 'TextHighlight'] = "TextHighlight";
        TypeEnum[TypeEnum["TextRedaction"] = 'TextRedaction'] = "TextRedaction";
        TypeEnum[TypeEnum["TextReplacement"] = 'TextReplacement'] = "TextReplacement";
        TypeEnum[TypeEnum["TextStrikeout"] = 'TextStrikeout'] = "TextStrikeout";
        TypeEnum[TypeEnum["TextUnderline"] = 'TextUnderline'] = "TextUnderline";
        TypeEnum[TypeEnum["Watermark"] = 'Watermark'] = "Watermark";
        TypeEnum[TypeEnum["Image"] = 'Image'] = "Image";
        TypeEnum[TypeEnum["TextSquiggly"] = 'TextSquiggly'] = "TextSquiggly";
    })(TypeEnum = AnnotationInfo.TypeEnum || (AnnotationInfo.TypeEnum = {}));
    let PenStyleEnum;
    (function (PenStyleEnum) {
        PenStyleEnum[PenStyleEnum["Solid"] = 'Solid'] = "Solid";
        PenStyleEnum[PenStyleEnum["Dash"] = 'Dash'] = "Dash";
        PenStyleEnum[PenStyleEnum["DashDot"] = 'DashDot'] = "DashDot";
        PenStyleEnum[PenStyleEnum["Dot"] = 'Dot'] = "Dot";
        PenStyleEnum[PenStyleEnum["LongDash"] = 'LongDash'] = "LongDash";
        PenStyleEnum[PenStyleEnum["DashDotDot"] = 'DashDotDot'] = "DashDotDot";
    })(PenStyleEnum = AnnotationInfo.PenStyleEnum || (AnnotationInfo.PenStyleEnum = {}));
})(AnnotationInfo || (exports.AnnotationInfo = AnnotationInfo = {}));
// tslint:enable:quotemark
/**
 * Describes annotation reply properties
 */
class AnnotationReplyInfo {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return AnnotationReplyInfo.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.AnnotationReplyInfo = AnnotationReplyInfo;
/**
 * Attribute type map
 */
AnnotationReplyInfo.attributeTypeMap = [
    {
        name: "id",
        baseName: "id",
        type: "number",
    },
    {
        name: "userId",
        baseName: "userId",
        type: "number",
    },
    {
        name: "userName",
        baseName: "userName",
        type: "string",
    },
    {
        name: "userEmail",
        baseName: "userEmail",
        type: "string",
    },
    {
        name: "comment",
        baseName: "comment",
        type: "string",
    },
    {
        name: "repliedOn",
        baseName: "repliedOn",
        type: "Date",
    },
    {
        name: "parentReplyId",
        baseName: "parentReplyId",
        type: "number",
    }
];
class ApiError {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return ApiError.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.ApiError = ApiError;
/**
 * Attribute type map
 */
ApiError.attributeTypeMap = [
    {
        name: "code",
        baseName: "code",
        type: "string",
    },
    {
        name: "message",
        baseName: "message",
        type: "string",
    },
    {
        name: "description",
        baseName: "description",
        type: "string",
    },
    {
        name: "dateTime",
        baseName: "dateTime",
        type: "Date",
    },
    {
        name: "innerError",
        baseName: "innerError",
        type: "ApiError",
    }
];
class ApiErrorResponse {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return ApiErrorResponse.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.ApiErrorResponse = ApiErrorResponse;
/**
 * Attribute type map
 */
ApiErrorResponse.attributeTypeMap = [
    {
        name: "requestId",
        baseName: "requestId",
        type: "string",
    },
    {
        name: "error",
        baseName: "error",
        type: "ApiError",
    }
];
/**
 * Metered license consumption information
 */
class ConsumptionResult {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return ConsumptionResult.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.ConsumptionResult = ConsumptionResult;
/**
 * Attribute type map
 */
ConsumptionResult.attributeTypeMap = [
    {
        name: "credit",
        baseName: "credit",
        type: "number",
    },
    {
        name: "quantity",
        baseName: "quantity",
        type: "number",
    },
    {
        name: "billedApiCalls",
        baseName: "billedApiCalls",
        type: "number",
    }
];
/**
 * Class for disc space information.
 */
class DiscUsage {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return DiscUsage.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.DiscUsage = DiscUsage;
/**
 * Attribute type map
 */
DiscUsage.attributeTypeMap = [
    {
        name: "usedSize",
        baseName: "usedSize",
        type: "number",
    },
    {
        name: "totalSize",
        baseName: "totalSize",
        type: "number",
    }
];
/**
 * Describes document basic info
 */
class DocumentInfo {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return DocumentInfo.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.DocumentInfo = DocumentInfo;
/**
 * Attribute type map
 */
DocumentInfo.attributeTypeMap = [
    {
        name: "name",
        baseName: "name",
        type: "string",
    },
    {
        name: "path",
        baseName: "path",
        type: "string",
    },
    {
        name: "extension",
        baseName: "extension",
        type: "string",
    },
    {
        name: "fileFormat",
        baseName: "fileFormat",
        type: "string",
    },
    {
        name: "size",
        baseName: "size",
        type: "number",
    },
    {
        name: "dateModified",
        baseName: "dateModified",
        type: "Date",
    },
    {
        name: "pages",
        baseName: "pages",
        type: "Array<PageInfo>",
    }
];
/**
 * The error details
 */
class ErrorDetails {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return ErrorDetails.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.ErrorDetails = ErrorDetails;
/**
 * Attribute type map
 */
ErrorDetails.attributeTypeMap = [
    {
        name: "requestId",
        baseName: "requestId",
        type: "string",
    },
    {
        name: "date",
        baseName: "date",
        type: "Date",
    }
];
/**
 * File info
 */
class FileInfo {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return FileInfo.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.FileInfo = FileInfo;
/**
 * Attribute type map
 */
FileInfo.attributeTypeMap = [
    {
        name: "filePath",
        baseName: "filePath",
        type: "string",
    },
    {
        name: "storageName",
        baseName: "storageName",
        type: "string",
    },
    {
        name: "versionId",
        baseName: "versionId",
        type: "string",
    },
    {
        name: "password",
        baseName: "password",
        type: "string",
    }
];
/**
 * File versions FileVersion.
 */
class FileVersions {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return FileVersions.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.FileVersions = FileVersions;
/**
 * Attribute type map
 */
FileVersions.attributeTypeMap = [
    {
        name: "value",
        baseName: "value",
        type: "Array<FileVersion>",
    }
];
/**
 * Files list
 */
class FilesList {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return FilesList.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.FilesList = FilesList;
/**
 * Attribute type map
 */
FilesList.attributeTypeMap = [
    {
        name: "value",
        baseName: "value",
        type: "Array<StorageFile>",
    }
];
/**
 * File upload result
 */
class FilesUploadResult {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return FilesUploadResult.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.FilesUploadResult = FilesUploadResult;
/**
 * Attribute type map
 */
FilesUploadResult.attributeTypeMap = [
    {
        name: "uploaded",
        baseName: "uploaded",
        type: "Array<string>",
    },
    {
        name: "errors",
        baseName: "errors",
        type: "Array<Error>",
    }
];
/**
 * File format
 */
class Format {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return Format.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.Format = Format;
/**
 * Attribute type map
 */
Format.attributeTypeMap = [
    {
        name: "extension",
        baseName: "extension",
        type: "string",
    },
    {
        name: "fileFormat",
        baseName: "fileFormat",
        type: "string",
    }
];
/**
 * Describes object which contains list of supported file formats
 */
class FormatsResult {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return FormatsResult.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.FormatsResult = FormatsResult;
/**
 * Attribute type map
 */
FormatsResult.attributeTypeMap = [
    {
        name: "formats",
        baseName: "formats",
        type: "Array<Format>",
    }
];
/**
 * Provides information for the object link This is supposed to be an atom:link, therefore it should have all attributes specified here http://tools.ietf.org/html/rfc4287#section-4.2.7
 */
class Link {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return Link.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.Link = Link;
/**
 * Attribute type map
 */
Link.attributeTypeMap = [
    {
        name: "href",
        baseName: "href",
        type: "string",
    },
    {
        name: "rel",
        baseName: "rel",
        type: "string",
    },
    {
        name: "type",
        baseName: "type",
        type: "string",
    },
    {
        name: "title",
        baseName: "title",
        type: "string",
    }
];
/**
 * Reference to document
 */
class LinkElement {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return LinkElement.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.LinkElement = LinkElement;
/**
 * Attribute type map
 */
LinkElement.attributeTypeMap = [
    {
        name: "link",
        baseName: "link",
        type: "AnnotationApiLink",
    }
];
/**
 * Error
 */
class ModelError {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return ModelError.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.ModelError = ModelError;
/**
 * Attribute type map
 */
ModelError.attributeTypeMap = [
    {
        name: "code",
        baseName: "code",
        type: "string",
    },
    {
        name: "message",
        baseName: "message",
        type: "string",
    },
    {
        name: "description",
        baseName: "description",
        type: "string",
    },
    {
        name: "innerError",
        baseName: "innerError",
        type: "ErrorDetails",
    }
];
/**
 * Object exists
 */
class ObjectExist {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return ObjectExist.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.ObjectExist = ObjectExist;
/**
 * Attribute type map
 */
ObjectExist.attributeTypeMap = [
    {
        name: "exists",
        baseName: "exists",
        type: "boolean",
    },
    {
        name: "isFolder",
        baseName: "isFolder",
        type: "boolean",
    }
];
/**
 * Represents collection of document pages image representations
 */
class PageImages {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return PageImages.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.PageImages = PageImages;
/**
 * Attribute type map
 */
PageImages.attributeTypeMap = [
    {
        name: "totalCount",
        baseName: "totalCount",
        type: "number",
    },
    {
        name: "entries",
        baseName: "entries",
        type: "Array<PageImage>",
    }
];
/**
 * Describes page information
 */
class PageInfo {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return PageInfo.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.PageInfo = PageInfo;
/**
 * Attribute type map
 */
PageInfo.attributeTypeMap = [
    {
        name: "number",
        baseName: "number",
        type: "number",
    },
    {
        name: "width",
        baseName: "width",
        type: "number",
    },
    {
        name: "height",
        baseName: "height",
        type: "number",
    }
];
/**
 * Describes point where annotation will be placed
 */
class Point {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return Point.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.Point = Point;
/**
 * Attribute type map
 */
Point.attributeTypeMap = [
    {
        name: "x",
        baseName: "x",
        type: "number",
    },
    {
        name: "y",
        baseName: "y",
        type: "number",
    }
];
/**
 * Represents options for GetPages API method
 */
class PreviewOptions {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return PreviewOptions.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.PreviewOptions = PreviewOptions;
/**
 * Attribute type map
 */
PreviewOptions.attributeTypeMap = [
    {
        name: "fileInfo",
        baseName: "fileInfo",
        type: "FileInfo",
    },
    {
        name: "format",
        baseName: "format",
        type: "PreviewOptions.FormatEnum",
    },
    {
        name: "pageNumbers",
        baseName: "pageNumbers",
        type: "Array<number>",
    },
    {
        name: "width",
        baseName: "width",
        type: "number",
    },
    {
        name: "height",
        baseName: "height",
        type: "number",
    },
    {
        name: "resolution",
        baseName: "resolution",
        type: "number",
    },
    {
        name: "renderComments",
        baseName: "renderComments",
        type: "boolean",
    },
    {
        name: "renderAnnotations",
        baseName: "renderAnnotations",
        type: "boolean",
    },
    {
        name: "fontsPath",
        baseName: "fontsPath",
        type: "string",
    }
];
// tslint:disable:quotemark
// tslint:disable-next-line:no-namespace
(function (PreviewOptions) {
    let FormatEnum;
    (function (FormatEnum) {
        FormatEnum[FormatEnum["PNG"] = 'PNG'] = "PNG";
        FormatEnum[FormatEnum["JPEG"] = 'JPEG'] = "JPEG";
        FormatEnum[FormatEnum["BMP"] = 'BMP'] = "BMP";
    })(FormatEnum = PreviewOptions.FormatEnum || (PreviewOptions.FormatEnum = {}));
})(PreviewOptions || (exports.PreviewOptions = PreviewOptions = {}));
// tslint:enable:quotemark
/**
 * Describes rectangle where annotation will be placed
 */
class Rectangle {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return Rectangle.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.Rectangle = Rectangle;
/**
 * Attribute type map
 */
Rectangle.attributeTypeMap = [
    {
        name: "x",
        baseName: "x",
        type: "number",
    },
    {
        name: "y",
        baseName: "y",
        type: "number",
    },
    {
        name: "width",
        baseName: "width",
        type: "number",
    },
    {
        name: "height",
        baseName: "height",
        type: "number",
    }
];
/**
 * Options for removing annotations
 */
class RemoveOptions {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return RemoveOptions.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.RemoveOptions = RemoveOptions;
/**
 * Attribute type map
 */
RemoveOptions.attributeTypeMap = [
    {
        name: "fileInfo",
        baseName: "fileInfo",
        type: "FileInfo",
    },
    {
        name: "annotationIds",
        baseName: "annotationIds",
        type: "Array<number>",
    },
    {
        name: "outputPath",
        baseName: "outputPath",
        type: "string",
    }
];
/**
 * Storage exists
 */
class StorageExist {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return StorageExist.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.StorageExist = StorageExist;
/**
 * Attribute type map
 */
StorageExist.attributeTypeMap = [
    {
        name: "exists",
        baseName: "exists",
        type: "boolean",
    }
];
/**
 * File or folder information
 */
class StorageFile {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return StorageFile.attributeTypeMap;
    }
    constructor(init) {
        Object.assign(this, init);
    }
}
exports.StorageFile = StorageFile;
/**
 * Attribute type map
 */
StorageFile.attributeTypeMap = [
    {
        name: "name",
        baseName: "name",
        type: "string",
    },
    {
        name: "isFolder",
        baseName: "isFolder",
        type: "boolean",
    },
    {
        name: "modifiedDate",
        baseName: "modifiedDate",
        type: "Date",
    },
    {
        name: "size",
        baseName: "size",
        type: "number",
    },
    {
        name: "path",
        baseName: "path",
        type: "string",
    }
];
/**
 * Provides information for the words api resource link
 */
class AnnotationApiLink extends Link {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return super.getAttributeTypeMap().concat(AnnotationApiLink.attributeTypeMap);
    }
    constructor(init) {
        super(init);
        Object.assign(this, init);
    }
}
exports.AnnotationApiLink = AnnotationApiLink;
/**
 * Attribute type map
 */
AnnotationApiLink.attributeTypeMap = [];
/**
 * File Version
 */
class FileVersion extends StorageFile {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return super.getAttributeTypeMap().concat(FileVersion.attributeTypeMap);
    }
    constructor(init) {
        super(init);
        Object.assign(this, init);
    }
}
exports.FileVersion = FileVersion;
/**
 * Attribute type map
 */
FileVersion.attributeTypeMap = [
    {
        name: "versionId",
        baseName: "versionId",
        type: "string",
    },
    {
        name: "isLatest",
        baseName: "isLatest",
        type: "boolean",
    }
];
/**
 * The document page image representation
 */
class PageImage extends LinkElement {
    /**
     * Returns attribute type map
     */
    static getAttributeTypeMap() {
        return super.getAttributeTypeMap().concat(PageImage.attributeTypeMap);
    }
    constructor(init) {
        super(init);
        Object.assign(this, init);
    }
}
exports.PageImage = PageImage;
/**
 * Attribute type map
 */
PageImage.attributeTypeMap = [
    {
        name: "number",
        baseName: "number",
        type: "number",
    }
];
const enumsMap = {
    "AnnotationInfo.HorizontalAlignmentEnum": AnnotationInfo.HorizontalAlignmentEnum,
    "AnnotationInfo.VerticalAlignmentEnum": AnnotationInfo.VerticalAlignmentEnum,
    "AnnotationInfo.TypeEnum": AnnotationInfo.TypeEnum,
    "AnnotationInfo.PenStyleEnum": AnnotationInfo.PenStyleEnum,
    "PreviewOptions.FormatEnum": PreviewOptions.FormatEnum,
};
exports.enumsMap = enumsMap;
const typeMap = {
    AnnotateOptions,
    AnnotationInfo,
    AnnotationReplyInfo,
    ApiError,
    ApiErrorResponse,
    ConsumptionResult,
    DiscUsage,
    DocumentInfo,
    ErrorDetails,
    FileInfo,
    FileVersions,
    FilesList,
    FilesUploadResult,
    Format,
    FormatsResult,
    Link,
    LinkElement,
    ModelError,
    ObjectExist,
    PageImages,
    PageInfo,
    Point,
    PreviewOptions,
    Rectangle,
    RemoveOptions,
    StorageExist,
    StorageFile,
    AnnotationApiLink,
    FileVersion,
    PageImage,
};
exports.typeMap = typeMap;
/**
 * Request model for Annotate operation.
 */
class AnnotateRequest {
    constructor(options) {
        this.options = options;
    }
}
exports.AnnotateRequest = AnnotateRequest;
/**
 * Request model for AnnotateDirect operation.
 */
class AnnotateDirectRequest {
    constructor(options) {
        this.options = options;
    }
}
exports.AnnotateDirectRequest = AnnotateDirectRequest;
/**
 * Request model for Extract operation.
 */
class ExtractRequest {
    constructor(fileInfo) {
        this.fileInfo = fileInfo;
    }
}
exports.ExtractRequest = ExtractRequest;
/**
 * Request model for RemoveAnnotations operation.
 */
class RemoveAnnotationsRequest {
    constructor(options) {
        this.options = options;
    }
}
exports.RemoveAnnotationsRequest = RemoveAnnotationsRequest;
/**
 * Request model for CopyFile operation.
 */
class CopyFileRequest {
    constructor(srcPath, destPath, srcStorageName, destStorageName, versionId) {
        this.srcPath = srcPath;
        this.destPath = destPath;
        this.srcStorageName = srcStorageName;
        this.destStorageName = destStorageName;
        this.versionId = versionId;
    }
}
exports.CopyFileRequest = CopyFileRequest;
/**
 * Request model for DeleteFile operation.
 */
class DeleteFileRequest {
    constructor(path, storageName, versionId) {
        this.path = path;
        this.storageName = storageName;
        this.versionId = versionId;
    }
}
exports.DeleteFileRequest = DeleteFileRequest;
/**
 * Request model for DownloadFile operation.
 */
class DownloadFileRequest {
    constructor(path, storageName, versionId) {
        this.path = path;
        this.storageName = storageName;
        this.versionId = versionId;
    }
}
exports.DownloadFileRequest = DownloadFileRequest;
/**
 * Request model for MoveFile operation.
 */
class MoveFileRequest {
    constructor(srcPath, destPath, srcStorageName, destStorageName, versionId) {
        this.srcPath = srcPath;
        this.destPath = destPath;
        this.srcStorageName = srcStorageName;
        this.destStorageName = destStorageName;
        this.versionId = versionId;
    }
}
exports.MoveFileRequest = MoveFileRequest;
/**
 * Request model for UploadFile operation.
 */
class UploadFileRequest {
    constructor(path, file, storageName) {
        this.path = path;
        this.file = file;
        this.storageName = storageName;
    }
}
exports.UploadFileRequest = UploadFileRequest;
/**
 * Request model for CopyFolder operation.
 */
class CopyFolderRequest {
    constructor(srcPath, destPath, srcStorageName, destStorageName) {
        this.srcPath = srcPath;
        this.destPath = destPath;
        this.srcStorageName = srcStorageName;
        this.destStorageName = destStorageName;
    }
}
exports.CopyFolderRequest = CopyFolderRequest;
/**
 * Request model for CreateFolder operation.
 */
class CreateFolderRequest {
    constructor(path, storageName) {
        this.path = path;
        this.storageName = storageName;
    }
}
exports.CreateFolderRequest = CreateFolderRequest;
/**
 * Request model for DeleteFolder operation.
 */
class DeleteFolderRequest {
    constructor(path, storageName, recursive) {
        this.path = path;
        this.storageName = storageName;
        this.recursive = recursive;
    }
}
exports.DeleteFolderRequest = DeleteFolderRequest;
/**
 * Request model for GetFilesList operation.
 */
class GetFilesListRequest {
    constructor(path, storageName) {
        this.path = path;
        this.storageName = storageName;
    }
}
exports.GetFilesListRequest = GetFilesListRequest;
/**
 * Request model for MoveFolder operation.
 */
class MoveFolderRequest {
    constructor(srcPath, destPath, srcStorageName, destStorageName) {
        this.srcPath = srcPath;
        this.destPath = destPath;
        this.srcStorageName = srcStorageName;
        this.destStorageName = destStorageName;
    }
}
exports.MoveFolderRequest = MoveFolderRequest;
/**
 * Request model for GetInfo operation.
 */
class GetInfoRequest {
    constructor(fileInfo) {
        this.fileInfo = fileInfo;
    }
}
exports.GetInfoRequest = GetInfoRequest;
/**
 * Request model for DeletePages operation.
 */
class DeletePagesRequest {
    constructor(fileInfo) {
        this.fileInfo = fileInfo;
    }
}
exports.DeletePagesRequest = DeletePagesRequest;
/**
 * Request model for GetPages operation.
 */
class GetPagesRequest {
    constructor(options) {
        this.options = options;
    }
}
exports.GetPagesRequest = GetPagesRequest;
/**
 * Request model for GetDiscUsage operation.
 */
class GetDiscUsageRequest {
    constructor(storageName) {
        this.storageName = storageName;
    }
}
exports.GetDiscUsageRequest = GetDiscUsageRequest;
/**
 * Request model for GetFileVersions operation.
 */
class GetFileVersionsRequest {
    constructor(path, storageName) {
        this.path = path;
        this.storageName = storageName;
    }
}
exports.GetFileVersionsRequest = GetFileVersionsRequest;
/**
 * Request model for ObjectExists operation.
 */
class ObjectExistsRequest {
    constructor(path, storageName, versionId) {
        this.path = path;
        this.storageName = storageName;
        this.versionId = versionId;
    }
}
exports.ObjectExistsRequest = ObjectExistsRequest;
/**
 * Request model for StorageExists operation.
 */
class StorageExistsRequest {
    constructor(storageName) {
        this.storageName = storageName;
    }
}
exports.StorageExistsRequest = StorageExistsRequest;