dpu-cloud-sdk 1.0.0

package/dist/ServiceIntegration.d.ts

@@ -0,0 +1,20 @@
+import { InitUploadResponse, PresignURLResponse, ObjectDetail, CompleteMultipartUploadResponse, MultiPresignURLResponse } from "./models/ResponseModel";
+export declare class ServiceIntegration {
+    constructor();
+    getUrlToDownload(bucketName: string, fileName: string, accessToken?: string): Promise<string | null | undefined>;
+    fetchChunkFile(url: string, start: number, end: number): Promise<ArrayBuffer>;
+    uploadSmallFile(bucketName: string, fileName: string, buffer: Buffer, accessToken: string, cancellationToken: AbortController, onProgress?: (percentCompleted: number) => void, reGetAccessToken?: () => string, isGetInfo?: boolean, preSignUrl?: PresignURLResponse): Promise<unknown>;
+    private generatePresignedUrl;
+    private uploadChildFile;
+    uploadLargeFile(bucketName: string, fileName: string, buffer: Buffer, accessToken: string, cancellationToken: AbortController, onProgress?: (percentCompleted: number) => void, reGetAccessToken?: () => string, initUpload?: InitUploadResponse, isGetInfo?: boolean): Promise<unknown>;
+    validateFileSize(fileName: string, fileSize: number): Promise<void>;
+    private isFileSizeAllowed;
+    calculateNumberOfChunks(fileSize: number): number;
+    getObjectDetail(bucketName: string, fileName: string, accessToken?: string): Promise<ObjectDetail | null>;
+    initMultiPartUpload(bucketName: string, fileName: string, accessToken?: string, autoCreateBucket?: boolean | false, cancellationToken?: AbortController): Promise<InitUploadResponse | undefined>;
+    generatePresignedUrls(bucketName: string, fileName: string, initUpload: InitUploadResponse, totalPart: number, accessToken: string, cancellationToken?: AbortController): Promise<string[] | null | undefined>;
+    throwIfCancellationRequested(cancellationToken: AbortController, fileName: string): void;
+    readFileBytes(file: File, start: number, end: number): Promise<ArrayBuffer>;
+    completeMultipartUpload(bucketName: string, fileName: string, uploadId: string, eTags: object, accessToken?: string, cancellationToken?: AbortController): Promise<false | CompleteMultipartUploadResponse | undefined>;
+    generateMultiPresignedUrl(bucketName: string, filesName: string[], accessToken?: string, cancellationToken?: AbortController): Promise<MultiPresignURLResponse | null | undefined>;
+}

package/dist/ServiceIntegration.js

@@ -0,0 +1,506 @@
+import { ApiStatus, ConfigFileRules, Path } from "./utils/Constants";
+import { validString } from "./utils/Helper";
+export class ServiceIntegration {
+    constructor() { }
+    async getUrlToDownload(bucketName, fileName, accessToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.GetUrlDownload}`;
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+                "ngrok-skip-browser-warning": true,
+            };
+            let queryParams;
+            if (validString(bucketName)) {
+                queryParams = { ...queryParams, bucketName: bucketName };
+            }
+            if (validString(fileName)) {
+                queryParams = { ...queryParams, fileName: fileName };
+            }
+            const response = await fetch(`${url}?${new URLSearchParams(queryParams)}`, {
+                method: "GET",
+                headers: headers,
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to generate url download with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to generate url download with status ${response.statusText} and error: ${response.statusText}`);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`Error when generate url download: ${error}`);
+        }
+    }
+    async fetchChunkFile(url, start, end) {
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Range: `bytes=${start}-${end}`,
+                },
+            });
+            if (!response.ok) {
+                const error = `Fail to fetch chunk file with status ${response.statusText} and error: ${await response.text()}`;
+                throw new Error(error);
+            }
+            return await response.arrayBuffer();
+        }
+        catch (error) {
+            console.error(`Error when download file: ${error}`);
+            throw error;
+        }
+    }
+    //#region Upload small file
+    async uploadSmallFile(bucketName, fileName, buffer, 
+    // file: File,
+    accessToken, cancellationToken, onProgress, reGetAccessToken, isGetInfo, preSignUrl) {
+        if (!preSignUrl) {
+            const presignUrlResponse = await this.generatePresignedUrl(bucketName, fileName, accessToken, cancellationToken);
+            if (!presignUrlResponse) {
+                return new Promise((resolve, reject) => {
+                    reject(`Fail to generate presigned url for file ${fileName}`);
+                });
+            }
+            preSignUrl = presignUrlResponse;
+        }
+        var responseUploadChild = await this.uploadChildFile(preSignUrl, buffer, cancellationToken);
+        if (!responseUploadChild) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to upload file ${fileName}`);
+            });
+        }
+        if (isGetInfo === true) {
+            const objectDetail = await this.getObjectDetail(bucketName, fileName, accessToken);
+            if (!objectDetail) {
+                return new Promise((resolve, reject) => {
+                    reject(`Fail to get object detail for file ${fileName}`);
+                });
+            }
+            const fileModel = {
+                bucketName: bucketName,
+                fileName: fileName,
+                contentLength: buffer.length,
+                versionFile: objectDetail.versionId,
+                dateVersionFile: objectDetail.lastModified,
+            };
+            return new Promise((resolve, reject) => {
+                resolve(fileModel);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            resolve({
+                bucketName: bucketName,
+                fileName: fileName,
+                contentLength: buffer.length,
+                versionFile: null,
+                dateVersionFile: null,
+            });
+        });
+    }
+    async generatePresignedUrl(bucketName, fileName, accessToken, cancellationToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.GeneratePresignedUrl}`;
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+                "ngrok-skip-browser-warning": true,
+            };
+            let queryParams = {
+                setPermission: false,
+            };
+            if (validString(bucketName)) {
+                queryParams = { ...queryParams, bucketName: bucketName };
+            }
+            if (validString(fileName)) {
+                queryParams = { ...queryParams, objectName: fileName };
+            }
+            const response = await fetch(`${url}?${new URLSearchParams(queryParams)}`, {
+                method: "GET",
+                headers: headers,
+                signal: cancellationToken?.signal
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to generate presigned urls with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to generate presigned urls with status ${response.statusText} and error: ${response.statusText}`);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`Error when generate presigned urls: ${error}`);
+        }
+    }
+    async uploadChildFile(presignUrlResponse, buffer, cancellationToken) {
+        try {
+            const response = await fetch(presignUrlResponse.url, {
+                method: "PUT",
+                headers: presignUrlResponse.headers,
+                body: buffer,
+                signal: cancellationToken?.signal
+            });
+            if (response.status === ApiStatus.Success) {
+                var eTag = response.headers.get("ETag");
+                if (eTag)
+                    return eTag.replace(/^"|"$/g, "");
+            }
+            else {
+                console.error(`Fail to upload child file with status ${response.statusText} and error: ${response.statusText}`);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`Error when upload child file: ${error}`);
+        }
+    }
+    //#endregion
+    //#region Upload large file
+    async uploadLargeFile(bucketName, fileName, buffer, accessToken, cancellationToken, onProgress, reGetAccessToken, initUpload, isGetInfo) {
+        await this.validateFileSize(fileName, buffer.length);
+        // init multi upload
+        if (!initUpload) {
+            initUpload = await this.initMultiPartUpload(bucketName, fileName, accessToken, false, cancellationToken);
+        }
+        if (!initUpload) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to initiate multipart upload for file ${fileName}`);
+            });
+        }
+        var numberOfChunks = this.calculateNumberOfChunks(buffer.length);
+        const urls = await this.generatePresignedUrls(bucketName, fileName, initUpload, numberOfChunks, accessToken, cancellationToken);
+        if (!urls) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to generate presigned urls for file ${fileName}`);
+            });
+        }
+        var chunksUploaded = 0;
+        var start = 0;
+        const eTags = {};
+        while (chunksUploaded < numberOfChunks) {
+            this.throwIfCancellationRequested(cancellationToken, fileName);
+            var end = Math.min(start + ConfigFileRules.ChunkSize, buffer.length);
+            // var fileChunk: ArrayBuffer = await this.readFileBytes(file, start, end);
+            const sliced = buffer.subarray(start, end); // lấy phần con của buffer
+            const fileChunk = sliced.buffer.slice(sliced.byteOffset, sliced.byteOffset + sliced.byteLength);
+            this.throwIfCancellationRequested(cancellationToken, fileName);
+            var url = urls[chunksUploaded];
+            var responseUploadChild = await this.uploadChildFile({ url: url, headers: initUpload.headers }, fileChunk);
+            if (!responseUploadChild) {
+                return new Promise((resolve, reject) => {
+                    reject(`Fail to upload chunk ${chunksUploaded} of file ${fileName}`);
+                });
+            }
+            Object.defineProperty(eTags, chunksUploaded + 1, {
+                value: responseUploadChild,
+                enumerable: true,
+            });
+            chunksUploaded++;
+            start = end;
+            var percentCompleted = (chunksUploaded / numberOfChunks) * 100;
+            onProgress?.(percentCompleted);
+            // console.log(`${requestId} Number of chunks uploaded : ${chunksUploaded}`);
+        }
+        var completeResponse = await this.completeMultipartUpload(bucketName, fileName, initUpload.uploadId, eTags, accessToken, cancellationToken);
+        onProgress?.(100);
+        if (!completeResponse) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to complete multipart upload for file ${fileName}`);
+            });
+        }
+        if (isGetInfo === false) {
+            return new Promise((resolve, reject) => {
+                resolve(fileName);
+            });
+        }
+        else {
+            const objectDetail = await this.getObjectDetail(bucketName, fileName, accessToken);
+            if (!objectDetail) {
+                return new Promise((resolve, reject) => {
+                    reject(`Fail to get object detail for file ${fileName}`);
+                });
+            }
+            const fileModel = {
+                bucketName: bucketName,
+                fileName: fileName,
+                contentLength: buffer.length,
+                versionFile: objectDetail.versionId,
+                dateVersionFile: objectDetail.lastModified,
+            };
+            return new Promise((resolve, reject) => {
+                resolve(fileModel);
+            });
+        }
+    }
+    async validateFileSize(fileName, fileSize) {
+        var sizeAllowed = await this.isFileSizeAllowed(fileSize);
+        if (!sizeAllowed) {
+            console.error(`File size of ${fileName} too big to upload. Currently max file size allowed is ${Number(ConfigFileRules.MaxChunkCountAllowed) *
+                Number(ConfigFileRules.ChunkSize)} bytes`);
+            //   throw new OssApiError(`${requestId} File size too big to upload. Currently max file size allowed is ${Number(ConfigFileRules.MaxChunkCountAllowed) * Number(Constants.ChunkSize)} bytes`);
+        }
+    }
+    async isFileSizeAllowed(fileSize) {
+        const numberOfChunks = this.calculateNumberOfChunks(fileSize);
+        if (numberOfChunks > ConfigFileRules.MaxChunkCountAllowed) {
+            return false;
+        }
+        return true;
+    }
+    calculateNumberOfChunks(fileSize) {
+        if (fileSize == 0) {
+            return 1;
+        }
+        var numberOfChunks = Math.trunc(fileSize / ConfigFileRules.ChunkSize);
+        if (fileSize % ConfigFileRules.ChunkSize != 0) {
+            numberOfChunks++;
+        }
+        return numberOfChunks;
+    }
+    async getObjectDetail(bucketName, fileName, accessToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.GetObjectDetail}`;
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+                "ngrok-skip-browser-warning": true,
+            };
+            let queryParams;
+            if (validString(bucketName)) {
+                queryParams = { ...queryParams, bucketName: bucketName };
+            }
+            if (validString(fileName)) {
+                queryParams = { ...queryParams, objectName: fileName };
+            }
+            const response = await fetch(`${url}?${new URLSearchParams(queryParams)}`, {
+                method: "GET",
+                headers: headers,
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to generate presigned urls with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to generate presigned urls with status ${response.statusText} and error: ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error when get file info: ${error}`);
+        }
+        return null;
+    }
+    async initMultiPartUpload(bucketName, fileName, accessToken, autoCreateBucket, cancellationToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.InitiateMultipartUpload}`;
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+                "ngrok-skip-browser-warning": true,
+            };
+            let queryParams;
+            if (validString(bucketName)) {
+                queryParams = { ...queryParams, bucketName: bucketName };
+            }
+            if (validString(fileName)) {
+                queryParams = { ...queryParams, objectName: fileName };
+            }
+            if (autoCreateBucket === true) {
+                queryParams = { ...queryParams, autoCreateBucket: autoCreateBucket };
+            }
+            queryParams = { ...queryParams, setPermission: false };
+            const response = await fetch(`${url}?${new URLSearchParams(queryParams)}`, {
+                method: "GET",
+                headers: headers,
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to initiate multipart upload with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to initiate multipart upload with status ${response.statusText} and error: ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error when initiate multipart upload: ${error}`);
+        }
+        return undefined;
+    }
+    async generatePresignedUrls(bucketName, fileName, initUpload, totalPart, accessToken, cancellationToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.GeneratePresignedUrls}`;
+            const headers = initUpload.headers;
+            let queryParams;
+            if (validString(bucketName)) {
+                queryParams = { ...queryParams, bucketName: bucketName };
+            }
+            if (validString(fileName)) {
+                queryParams = { ...queryParams, objectName: fileName };
+            }
+            if (validString(initUpload.uploadId)) {
+                queryParams = { ...queryParams, uploadId: initUpload.uploadId };
+            }
+            if (totalPart > 0) {
+                queryParams = { ...queryParams, totalPart: totalPart };
+            }
+            const newHeaders = {
+                Authorization: `Bearer ${accessToken}`,
+                "ngrok-skip-browser-warning": true,
+            };
+            const response = await fetch(`${url}?${new URLSearchParams(queryParams)}`, {
+                method: "GET",
+                headers: { ...headers, ...newHeaders },
+                signal: cancellationToken?.signal
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to generate presigned urls with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to generate presigned urls with status ${response.statusText} and error: ${response.statusText}`);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`Error when generate presigned urls: ${error}`);
+        }
+    }
+    throwIfCancellationRequested(cancellationToken, fileName) {
+        if (cancellationToken.signal.aborted) {
+            console.error(`${fileName} Cancellation requested.`);
+            cancellationToken.signal.throwIfAborted();
+        }
+    }
+    // public readFileBytes(file: Buffer, start: number, end: number): Buffer {
+    //   const fileReader = file.subarray(start, end);
+    //   return fileReader;
+    // }
+    readFileBytes(file, start, end) {
+        return new Promise((resolve, reject) => {
+            const blob = file.slice(start, end); // tạo blob từ phần file cần đọc
+            const reader = new FileReader();
+            reader.onload = () => {
+                if (reader.result instanceof ArrayBuffer) {
+                    resolve(reader.result);
+                }
+                else {
+                    reject(new Error("Failed to read as ArrayBuffer"));
+                }
+            };
+            reader.onerror = () => reject(reader.error);
+            reader.readAsArrayBuffer(blob); // đọc phần blob thành ArrayBuffer
+        });
+    }
+    async completeMultipartUpload(bucketName, fileName, uploadId, eTags, accessToken, cancellationToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.CompleteMultipartUpload}`;
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+                "ngrok-skip-browser-warning": true,
+            };
+            let body;
+            if (validString(bucketName)) {
+                body = { ...body, bucketName: bucketName };
+            }
+            if (validString(fileName)) {
+                body = { ...body, objectName: fileName };
+            }
+            if (validString(uploadId)) {
+                body = { ...body, uploadId: uploadId };
+            }
+            if (eTags) {
+                body = { ...body, eTags: eTags };
+            }
+            const bodyString = JSON.stringify(body);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: headers,
+                body: bodyString,
+                signal: cancellationToken?.signal
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to complete multiple part upload with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to complete multiple part upload with status ${response.statusText} and error: ${response.statusText}`);
+            }
+            return false;
+        }
+        catch (error) {
+            console.error(`Error when complete multiple part upload: ${error}`);
+        }
+    }
+    async generateMultiPresignedUrl(bucketName, filesName, accessToken, cancellationToken) {
+        try {
+            const url = `${Path.BaseURL}${Path.GenerateMultiPresignedURL}`;
+            // const url = `https://localhost:7193/api/Object/GenerateMultiPresignedURL`;
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+                "ngrok-skip-browser-warning": true,
+            };
+            const body = {
+                bucketName: bucketName,
+                objectNames: filesName,
+                setPermission: false
+            };
+            const bodyString = JSON.stringify(body);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: headers,
+                body: bodyString,
+                signal: cancellationToken?.signal
+            });
+            if (response.ok) {
+                const json = (await response.json());
+                if (json.statusCode === ApiStatus.Success) {
+                    return json.data;
+                }
+                else {
+                    console.error(`Fail to generate multiple presigned url with message error: ${json.message}`);
+                }
+            }
+            else {
+                console.error(`Fail to generate multiple presigned url with status ${response.statusText} and error: ${response.statusText}`);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`Error when generate multiple presigned url: ${error}`);
+        }
+    }
+}

package/dist/api/auth.d.ts

@@ -0,0 +1,3 @@
+import { BaseReponseModel, Token } from "../models/ResponseModel";
+import { Scope } from "../utils/Enum";
+export declare const GetToken: (clientId: string, clientSecret: string, scopes: Scope[]) => Promise<BaseReponseModel<Token>>;

package/dist/api/auth.js

@@ -0,0 +1,10 @@
+import { Path, PathAuth } from "../utils/Constants";
+import { baseFetch } from "./translate";
+export const GetToken = async (clientId, clientSecret, scopes) => {
+    const request = {
+        clientId,
+        clientSecret,
+        scopes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+    };
+    return baseFetch(`${Path.BaseURL}${PathAuth.GetToken}`, "POST", "", request);
+};

package/dist/api/compress.d.ts

@@ -0,0 +1,4 @@
+import { BaseReponseModel, CompressionResponse, CompressStatus } from "../models/ResponseModel";
+export declare const CompressFolder: (accessToken: string, bucketName: string, rootFolder?: string) => Promise<BaseReponseModel<CompressionResponse>>;
+export declare const GetStatusCompress: (requestIds: string[], accessToken: string) => Promise<BaseReponseModel<CompressStatus>>;
+export declare const CancelDownload: (requestId: string, accessToken: string) => Promise<BaseReponseModel<boolean>>;

package/dist/api/compress.js

@@ -0,0 +1,16 @@
+import { Path, PathManagement } from "../utils/Constants";
+import { baseFetch } from "./translate";
+export const CompressFolder = async (accessToken, bucketName, rootFolder) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.CompressFolder}`, "POST", accessToken, {
+        bucketName,
+        rootFolder
+    });
+};
+export const GetStatusCompress = async (requestIds, accessToken) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.GetStatusCompress}`, "POST", accessToken, {
+        requestIds
+    });
+};
+export const CancelDownload = async (requestId, accessToken) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.CancelDownload}`, "DELETE", accessToken, requestId);
+};

package/dist/api/translate.d.ts

@@ -0,0 +1,8 @@
+import { GetStatusTranslateRequest, TranslateRequest } from "../models/RequestModel";
+import { BaseReponseModel, TranslateInfo, TranslateStatusInfo } from "../models/ResponseModel";
+export declare const baseFetch: <T, T1>(url: string, method: string, accessToken: string, request?: T1) => Promise<BaseReponseModel<T>>;
+export declare const TranslateFile: (accessToken: string, request: TranslateRequest) => Promise<BaseReponseModel<TranslateInfo>>;
+export declare const GetStatusTranslate: (accessToken: string, request: string[]) => Promise<BaseReponseModel<TranslateStatusInfo[]>>;
+export declare const GetStatusTranslateFile: (accessToken: string, request: GetStatusTranslateRequest[]) => Promise<BaseReponseModel<TranslateStatusInfo[]>>;
+export declare const GetEPSGRegionCode: (accessToken: string) => Promise<BaseReponseModel<string[]>>;
+export declare const GetFileTileSet: (accessToken: string, translateId: string) => Promise<BaseReponseModel<string>>;

package/dist/api/translate.js

@@ -0,0 +1,38 @@
+import { ApiStatus, Path, PathManagement } from "../utils/Constants";
+export const baseFetch = async (url, method, accessToken, request) => {
+    const response = await fetch(url, {
+        method: method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+            'ngrok-skip-browser-warning': true
+        },
+        body: JSON.stringify(request),
+    });
+    if (response.ok)
+        return response.json();
+    if (response.status === 401)
+        return {
+            statusCode: ApiStatus.Unauthorized,
+            message: "Unauthorized",
+            data: null,
+        };
+    return new Promise((resolve, reject) => {
+        reject(response.text);
+    });
+};
+export const TranslateFile = async (accessToken, request) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.TranslateFile}`, "POST", accessToken, request);
+};
+export const GetStatusTranslate = async (accessToken, request) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.GetStatusTranslate}`, "POST", accessToken, request);
+};
+export const GetStatusTranslateFile = async (accessToken, request) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.GetStatusTranslateFile}`, "POST", accessToken, request);
+};
+export const GetEPSGRegionCode = async (accessToken) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.GetEPSGRegionCode}`, "GET", accessToken);
+};
+export const GetFileTileSet = async (accessToken, translateId) => {
+    return baseFetch(`${Path.BaseURL}${PathManagement.GetFileTileSet}?translateId=${translateId}`, "GET", accessToken);
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./DPUClient";
+export * from "./models/RequestModel";
+export * from "./models/ResponseModel";
+export { dpuConfig } from "./utils/Config";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./DPUClient";
+export * from "./models/RequestModel";
+export * from "./models/ResponseModel";
+export { dpuConfig } from "./utils/Config";

package/dist/models/RequestModel.d.ts

@@ -0,0 +1,33 @@
+export type FileDownloadInfo = {
+    fullName: string;
+    contentLength?: number;
+};
+export type CompressFolderRequest = {
+    bucketName: string;
+    rootFolder?: string;
+};
+export type GetStatusCompressionRequest = {
+    requestIds: string[];
+};
+export interface TranslateRequest {
+    modelType: string;
+    epsgCode: string;
+    translatePos?: number[];
+}
+export interface FileTranslateRequest extends TranslateRequest {
+    bucketName?: string;
+    fileName?: string;
+    versionId?: string;
+    url?: string;
+}
+export interface URNTranslateRequest extends TranslateRequest {
+    urn?: string;
+    accessToken: string | null;
+    clientId: string | null;
+    clientSecret: string | null;
+}
+export interface GetStatusTranslateRequest {
+    bucketName: string;
+    fileName: string;
+    versionId: string;
+}

package/dist/models/RequestModel.js

@@ -0,0 +1,2 @@
+export {};
+//#endregion