readme.md

Aspose.Imaging.Cloud NodeJs API to easy resize your images or photos in your NodeJs application or Web service.

You can:

• resize raster images;
• resize multi-page images;
• resize vector images.

Interested ?

You may go further at : https://products.aspose.cloud/imaging/nodejs/

resize-apng.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.apng";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "apng";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "apng";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "apng";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "apng";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-bmp.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.bmp";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "bmp";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "bmp";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "bmp";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "bmp";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-cdr.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.cdr";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-cmx.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.cmx";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-dicom.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.dicom";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-djvu.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.djvu";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "tiff";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "tiff";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "tiff";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "tiff";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-dng.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.dng";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "bmp";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "bmp";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "bmp";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "bmp";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-emf.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.emf";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "emf";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "emf";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "emf";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "emf";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-emz.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.emz";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "emz";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "emz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "emz";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "emz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-eps.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.eps";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-gif.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.gif";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "gif";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "gif";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "gif";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "gif";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-jpeg.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.jpeg";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "jpeg";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "jpeg";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "jpeg";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "jpeg";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-jpeg2000.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.jpeg2000";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "jpeg2000";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "jpeg2000";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "jpeg2000";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "jpeg2000";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-odg.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.odg";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-otg.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.otg";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-png.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.png";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "png";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "png";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-psd.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.psd";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "psd";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "psd";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "psd";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "psd";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-svg.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.svg";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "wmz";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "wmz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "wmz";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "wmz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-svgz.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.svgz";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "svgz";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "svgz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "svgz";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "svgz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-tga.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.tga";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "tga";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "tga";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "tga";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "tga";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-tiff.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.tiff";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "tiff";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "tiff";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "tiff";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "tiff";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-webp.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.webp";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "webp";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "webp";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "webp";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "webp";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-wmf.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.wmf";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "wmf";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "wmf";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "wmf";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "wmf";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

resize-wmz.ts

import * as fs from "fs";
import * as path from "path";
import {ImagingBase} from "./imaging-base";
import {
    CreateResizedImageRequest, ResizeImageRequest,
    ImagingApi,
} from "@asposecloud/aspose-imaging-cloud";

const ImageFileName = "example_image.wmz";
const ImagesFolder = "ExampleImages";
const CloudFolder = "CloudImages";
const OutputFolder = "Output";

// Get ClientId and ClientSecret from https://dashboard.aspose.cloud/ 
// or use on-premise version (https://docs.aspose.cloud/imaging/getting-started/how-to-run-docker-container/)
const api = new ImagingApi(clientSecret, clientId, "https://api.aspose.cloud");

/**
* Resizes the image from cloud storage.
*/
public async ResizeImageFromStorage() {

    const localInputImage = fs.readFileSync(path.join(ImagesFolder, ImageFileName));
    const uploadFileRequest = new UploadFileRequest({path: path.join(CloudFolder, imageName), file: image});
    const result = await this.api.uploadFile(uploadFileRequest);
    if (result.errors.length > 0)
        console.log(`Uploading errors count: ${result.errors.length}`

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "wmz";     
    const width = 100;
    const height = 150;
    const folder = this.CloudFolder; // Input file is saved at the desired folder in the storage
    const storage = undefined; // We are using default Cloud Storage

    const request = new ResizeImageRequest({
            name: this.ImageFileName,
            format,
            width,
            height,
            folder,
            storage,
        });

    const resizedImage = await this.api.resizeImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "wmz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}

/**
* Resizes an image. Image data is passed in a request stream.
*/
public async CreateResizedImageFromRequest() {

    // Please refer to https://docs.aspose.cloud/imaging/supported-file-formats/#resize
    // for possible formats
    const format = "wmz";
    const width = 100;
    const height = 150;
    const outPath = undefined; // Path to updated file (if this is empty, response contains streamed image)
    const storage = undefined; // We are using default Cloud Storage

    const inputStream = fs.readFileSync(path.resolve(ImagesFolder, ImageFileName));
    const request = new CreateResizedImageRequest({
            imageData: inputStream,
            format,
            width,
            height,
            outPath,
            storage,
        });
    const resizedImage = await this.api.createResizedImage(request);

    // Save the image file to output folder
    const resizedImageName = ImageFileName.substr(0, ImageFileName.lastIndexOf(".")) + "wmz";
    const filePath = path.resolve(path.join(OutputFolder, resizedImageName));
    fs.writeFile(filePath, resizedImage, (err) => {
        if (err) {
            throw err;
            }
    });
}