aspose-barcode-cloud-node
Version:
Aspose.BarCode Cloud SDK for Node.js
1,522 lines (1,519 loc) • 66.7 kB
JavaScript
// src/multipart.ts
import crypto from "crypto";
var RequestFile = class {
constructor(name, filename, data, contentType) {
this.name = name;
this.filename = filename;
this.data = data;
this.contentType = contentType;
}
};
var Multipart = class {
constructor(textFields, files) {
const random = crypto.randomUUID();
this.boundary = "------------------------" + random.replace(/-/g, "");
const bodyLines = [];
for (const tuple of textFields) {
bodyLines.push(`--${this.boundary}`);
bodyLines.push(`Content-Disposition: form-data; name="${tuple[0]}"`);
bodyLines.push("");
bodyLines.push(tuple[1]);
}
for (const file of files || []) {
bodyLines.push(`--${this.boundary}`);
bodyLines.push(
`Content-Disposition: form-data; name="${file.name}"; filename="${file.filename || "filename"}"`
);
bodyLines.push(`Content-Type: ${file.contentType || "application/octet-stream"}`);
bodyLines.push("");
bodyLines.push(file.data.toString("binary"));
}
bodyLines.push(`--${this.boundary}--`);
this.body = Buffer.from(bodyLines.join("\r\n"), "binary");
this.headers = {
"Content-Type": `multipart/form-data; boundary=${this.boundary}`,
"Content-Length": this.body.length.toString()
};
}
};
// src/models.ts
var _ApiError = class _ApiError {
static getAttributeTypeMap() {
return _ApiError.attributeTypeMap;
}
};
_ApiError.attributeTypeMap = [
{
name: "code",
baseName: "code",
type: "string"
},
{
name: "message",
baseName: "message",
type: "string"
},
{
name: "description",
baseName: "description",
type: "string"
},
{
name: "dateTime",
baseName: "dateTime",
type: "Date"
},
{
name: "innerError",
baseName: "innerError",
type: "ApiError"
}
];
var ApiError = _ApiError;
var _ApiErrorResponse = class _ApiErrorResponse {
static getAttributeTypeMap() {
return _ApiErrorResponse.attributeTypeMap;
}
};
_ApiErrorResponse.attributeTypeMap = [
{
name: "requestId",
baseName: "requestId",
type: "string"
},
{
name: "error",
baseName: "error",
type: "ApiError"
}
];
var ApiErrorResponse = _ApiErrorResponse;
var BarcodeImageFormat = /* @__PURE__ */ ((BarcodeImageFormat2) => {
BarcodeImageFormat2["Png"] = "Png";
BarcodeImageFormat2["Jpeg"] = "Jpeg";
BarcodeImageFormat2["Svg"] = "Svg";
BarcodeImageFormat2["Tiff"] = "Tiff";
BarcodeImageFormat2["Gif"] = "Gif";
return BarcodeImageFormat2;
})(BarcodeImageFormat || {});
var _BarcodeImageParams = class _BarcodeImageParams {
static getAttributeTypeMap() {
return _BarcodeImageParams.attributeTypeMap;
}
};
_BarcodeImageParams.attributeTypeMap = [
{
name: "imageFormat",
baseName: "imageFormat",
type: "BarcodeImageFormat"
},
{
name: "textLocation",
baseName: "textLocation",
type: "CodeLocation"
},
{
name: "foregroundColor",
baseName: "foregroundColor",
type: "string"
},
{
name: "backgroundColor",
baseName: "backgroundColor",
type: "string"
},
{
name: "units",
baseName: "units",
type: "GraphicsUnit"
},
{
name: "resolution",
baseName: "resolution",
type: "number"
},
{
name: "imageHeight",
baseName: "imageHeight",
type: "number"
},
{
name: "imageWidth",
baseName: "imageWidth",
type: "number"
},
{
name: "rotationAngle",
baseName: "rotationAngle",
type: "number"
}
];
var BarcodeImageParams = _BarcodeImageParams;
var _BarcodeResponse = class _BarcodeResponse {
static getAttributeTypeMap() {
return _BarcodeResponse.attributeTypeMap;
}
};
_BarcodeResponse.attributeTypeMap = [
{
name: "barcodeValue",
baseName: "barcodeValue",
type: "string"
},
{
name: "type",
baseName: "type",
type: "string"
},
{
name: "region",
baseName: "region",
type: "Array<RegionPoint>"
},
{
name: "checksum",
baseName: "checksum",
type: "string"
}
];
var BarcodeResponse = _BarcodeResponse;
var _BarcodeResponseList = class _BarcodeResponseList {
static getAttributeTypeMap() {
return _BarcodeResponseList.attributeTypeMap;
}
};
_BarcodeResponseList.attributeTypeMap = [
{
name: "barcodes",
baseName: "barcodes",
type: "Array<BarcodeResponse>"
}
];
var BarcodeResponseList = _BarcodeResponseList;
var Code128EncodeMode = /* @__PURE__ */ ((Code128EncodeMode2) => {
Code128EncodeMode2["Auto"] = "Auto";
Code128EncodeMode2["CodeA"] = "CodeA";
Code128EncodeMode2["CodeB"] = "CodeB";
Code128EncodeMode2["CodeAb"] = "CodeAB";
Code128EncodeMode2["CodeC"] = "CodeC";
Code128EncodeMode2["CodeAc"] = "CodeAC";
Code128EncodeMode2["CodeBc"] = "CodeBC";
return Code128EncodeMode2;
})(Code128EncodeMode || {});
var _Code128Params = class _Code128Params {
static getAttributeTypeMap() {
return _Code128Params.attributeTypeMap;
}
};
_Code128Params.attributeTypeMap = [
{
name: "code128EncodeMode",
baseName: "code128EncodeMode",
type: "Code128EncodeMode"
}
];
var Code128Params = _Code128Params;
var CodeLocation = /* @__PURE__ */ ((CodeLocation2) => {
CodeLocation2["Below"] = "Below";
CodeLocation2["Above"] = "Above";
CodeLocation2["None"] = "None";
return CodeLocation2;
})(CodeLocation || {});
var DecodeBarcodeType = /* @__PURE__ */ ((DecodeBarcodeType2) => {
DecodeBarcodeType2["MostCommonlyUsed"] = "MostCommonlyUsed";
DecodeBarcodeType2["Qr"] = "QR";
DecodeBarcodeType2["AustraliaPost"] = "AustraliaPost";
DecodeBarcodeType2["AustralianPosteParcel"] = "AustralianPosteParcel";
DecodeBarcodeType2["Aztec"] = "Aztec";
DecodeBarcodeType2["Codabar"] = "Codabar";
DecodeBarcodeType2["CodablockF"] = "CodablockF";
DecodeBarcodeType2["Code11"] = "Code11";
DecodeBarcodeType2["Code128"] = "Code128";
DecodeBarcodeType2["Code16K"] = "Code16K";
DecodeBarcodeType2["Code32"] = "Code32";
DecodeBarcodeType2["Code39"] = "Code39";
DecodeBarcodeType2["Code39FullAscii"] = "Code39FullASCII";
DecodeBarcodeType2["Code93"] = "Code93";
DecodeBarcodeType2["CompactPdf417"] = "CompactPdf417";
DecodeBarcodeType2["DataLogic2of5"] = "DataLogic2of5";
DecodeBarcodeType2["DataMatrix"] = "DataMatrix";
DecodeBarcodeType2["DatabarExpanded"] = "DatabarExpanded";
DecodeBarcodeType2["DatabarExpandedStacked"] = "DatabarExpandedStacked";
DecodeBarcodeType2["DatabarLimited"] = "DatabarLimited";
DecodeBarcodeType2["DatabarOmniDirectional"] = "DatabarOmniDirectional";
DecodeBarcodeType2["DatabarStacked"] = "DatabarStacked";
DecodeBarcodeType2["DatabarStackedOmniDirectional"] = "DatabarStackedOmniDirectional";
DecodeBarcodeType2["DatabarTruncated"] = "DatabarTruncated";
DecodeBarcodeType2["DeutschePostIdentcode"] = "DeutschePostIdentcode";
DecodeBarcodeType2["DeutschePostLeitcode"] = "DeutschePostLeitcode";
DecodeBarcodeType2["DotCode"] = "DotCode";
DecodeBarcodeType2["DutchKix"] = "DutchKIX";
DecodeBarcodeType2["Ean13"] = "EAN13";
DecodeBarcodeType2["Ean14"] = "EAN14";
DecodeBarcodeType2["Ean8"] = "EAN8";
DecodeBarcodeType2["Gs1Aztec"] = "GS1Aztec";
DecodeBarcodeType2["Gs1Code128"] = "GS1Code128";
DecodeBarcodeType2["Gs1CompositeBar"] = "GS1CompositeBar";
DecodeBarcodeType2["Gs1DataMatrix"] = "GS1DataMatrix";
DecodeBarcodeType2["Gs1DotCode"] = "GS1DotCode";
DecodeBarcodeType2["Gs1HanXin"] = "GS1HanXin";
DecodeBarcodeType2["Gs1MicroPdf417"] = "GS1MicroPdf417";
DecodeBarcodeType2["Gs1Qr"] = "GS1QR";
DecodeBarcodeType2["HanXin"] = "HanXin";
DecodeBarcodeType2["HibcAztecLic"] = "HIBCAztecLIC";
DecodeBarcodeType2["HibcAztecPas"] = "HIBCAztecPAS";
DecodeBarcodeType2["HibcCode128Lic"] = "HIBCCode128LIC";
DecodeBarcodeType2["HibcCode128Pas"] = "HIBCCode128PAS";
DecodeBarcodeType2["HibcCode39Lic"] = "HIBCCode39LIC";
DecodeBarcodeType2["HibcCode39Pas"] = "HIBCCode39PAS";
DecodeBarcodeType2["HibcDataMatrixLic"] = "HIBCDataMatrixLIC";
DecodeBarcodeType2["HibcDataMatrixPas"] = "HIBCDataMatrixPAS";
DecodeBarcodeType2["Hibcqrlic"] = "HIBCQRLIC";
DecodeBarcodeType2["Hibcqrpas"] = "HIBCQRPAS";
DecodeBarcodeType2["Iata2of5"] = "IATA2of5";
DecodeBarcodeType2["Isbn"] = "ISBN";
DecodeBarcodeType2["Ismn"] = "ISMN";
DecodeBarcodeType2["Issn"] = "ISSN";
DecodeBarcodeType2["Itf14"] = "ITF14";
DecodeBarcodeType2["Itf6"] = "ITF6";
DecodeBarcodeType2["Interleaved2of5"] = "Interleaved2of5";
DecodeBarcodeType2["ItalianPost25"] = "ItalianPost25";
DecodeBarcodeType2["MacroPdf417"] = "MacroPdf417";
DecodeBarcodeType2["Mailmark"] = "Mailmark";
DecodeBarcodeType2["Matrix2of5"] = "Matrix2of5";
DecodeBarcodeType2["MaxiCode"] = "MaxiCode";
DecodeBarcodeType2["MicrE13B"] = "MicrE13B";
DecodeBarcodeType2["MicroPdf417"] = "MicroPdf417";
DecodeBarcodeType2["MicroQr"] = "MicroQR";
DecodeBarcodeType2["Msi"] = "MSI";
DecodeBarcodeType2["OneCode"] = "OneCode";
DecodeBarcodeType2["Opc"] = "OPC";
DecodeBarcodeType2["PatchCode"] = "PatchCode";
DecodeBarcodeType2["Pdf417"] = "Pdf417";
DecodeBarcodeType2["Pharmacode"] = "Pharmacode";
DecodeBarcodeType2["Planet"] = "Planet";
DecodeBarcodeType2["Postnet"] = "Postnet";
DecodeBarcodeType2["Pzn"] = "PZN";
DecodeBarcodeType2["RectMicroQr"] = "RectMicroQR";
DecodeBarcodeType2["Rm4Scc"] = "RM4SCC";
DecodeBarcodeType2["Scc14"] = "SCC14";
DecodeBarcodeType2["Sscc18"] = "SSCC18";
DecodeBarcodeType2["Standard2of5"] = "Standard2of5";
DecodeBarcodeType2["Supplement"] = "Supplement";
DecodeBarcodeType2["SwissPostParcel"] = "SwissPostParcel";
DecodeBarcodeType2["Upca"] = "UPCA";
DecodeBarcodeType2["Upce"] = "UPCE";
DecodeBarcodeType2["Vin"] = "VIN";
return DecodeBarcodeType2;
})(DecodeBarcodeType || {});
var ECIEncodings = /* @__PURE__ */ ((ECIEncodings2) => {
ECIEncodings2["None"] = "NONE";
ECIEncodings2["Iso88591"] = "ISO_8859_1";
ECIEncodings2["Iso88592"] = "ISO_8859_2";
ECIEncodings2["Iso88593"] = "ISO_8859_3";
ECIEncodings2["Iso88594"] = "ISO_8859_4";
ECIEncodings2["Iso88595"] = "ISO_8859_5";
ECIEncodings2["Iso88596"] = "ISO_8859_6";
ECIEncodings2["Iso88597"] = "ISO_8859_7";
ECIEncodings2["Iso88598"] = "ISO_8859_8";
ECIEncodings2["Iso88599"] = "ISO_8859_9";
ECIEncodings2["Iso885910"] = "ISO_8859_10";
ECIEncodings2["Iso885911"] = "ISO_8859_11";
ECIEncodings2["Iso885913"] = "ISO_8859_13";
ECIEncodings2["Iso885914"] = "ISO_8859_14";
ECIEncodings2["Iso885915"] = "ISO_8859_15";
ECIEncodings2["Iso885916"] = "ISO_8859_16";
ECIEncodings2["ShiftJis"] = "Shift_JIS";
ECIEncodings2["Win1250"] = "Win1250";
ECIEncodings2["Win1251"] = "Win1251";
ECIEncodings2["Win1252"] = "Win1252";
ECIEncodings2["Win1256"] = "Win1256";
ECIEncodings2["Utf16Be"] = "UTF16BE";
ECIEncodings2["Utf8"] = "UTF8";
ECIEncodings2["UsAscii"] = "US_ASCII";
ECIEncodings2["Big5"] = "Big5";
ECIEncodings2["Gb2312"] = "GB2312";
ECIEncodings2["EucKr"] = "EUC_KR";
ECIEncodings2["Gbk"] = "GBK";
ECIEncodings2["Gb18030"] = "GB18030";
ECIEncodings2["Utf16Le"] = "UTF16LE";
ECIEncodings2["Utf32Be"] = "UTF32BE";
ECIEncodings2["Utf32Le"] = "UTF32LE";
ECIEncodings2["Invariant"] = "INVARIANT";
ECIEncodings2["Binary"] = "BINARY";
return ECIEncodings2;
})(ECIEncodings || {});
var EncodeBarcodeType = /* @__PURE__ */ ((EncodeBarcodeType2) => {
EncodeBarcodeType2["Qr"] = "QR";
EncodeBarcodeType2["AustraliaPost"] = "AustraliaPost";
EncodeBarcodeType2["AustralianPosteParcel"] = "AustralianPosteParcel";
EncodeBarcodeType2["Aztec"] = "Aztec";
EncodeBarcodeType2["Codabar"] = "Codabar";
EncodeBarcodeType2["CodablockF"] = "CodablockF";
EncodeBarcodeType2["Code11"] = "Code11";
EncodeBarcodeType2["Code128"] = "Code128";
EncodeBarcodeType2["Code16K"] = "Code16K";
EncodeBarcodeType2["Code32"] = "Code32";
EncodeBarcodeType2["Code39"] = "Code39";
EncodeBarcodeType2["Code39FullAscii"] = "Code39FullASCII";
EncodeBarcodeType2["Code93"] = "Code93";
EncodeBarcodeType2["DataLogic2of5"] = "DataLogic2of5";
EncodeBarcodeType2["DataMatrix"] = "DataMatrix";
EncodeBarcodeType2["DatabarExpanded"] = "DatabarExpanded";
EncodeBarcodeType2["DatabarExpandedStacked"] = "DatabarExpandedStacked";
EncodeBarcodeType2["DatabarLimited"] = "DatabarLimited";
EncodeBarcodeType2["DatabarOmniDirectional"] = "DatabarOmniDirectional";
EncodeBarcodeType2["DatabarStacked"] = "DatabarStacked";
EncodeBarcodeType2["DatabarStackedOmniDirectional"] = "DatabarStackedOmniDirectional";
EncodeBarcodeType2["DatabarTruncated"] = "DatabarTruncated";
EncodeBarcodeType2["DeutschePostIdentcode"] = "DeutschePostIdentcode";
EncodeBarcodeType2["DeutschePostLeitcode"] = "DeutschePostLeitcode";
EncodeBarcodeType2["DotCode"] = "DotCode";
EncodeBarcodeType2["DutchKix"] = "DutchKIX";
EncodeBarcodeType2["Ean13"] = "EAN13";
EncodeBarcodeType2["Ean14"] = "EAN14";
EncodeBarcodeType2["Ean8"] = "EAN8";
EncodeBarcodeType2["Gs1Aztec"] = "GS1Aztec";
EncodeBarcodeType2["Gs1CodablockF"] = "GS1CodablockF";
EncodeBarcodeType2["Gs1Code128"] = "GS1Code128";
EncodeBarcodeType2["Gs1DataMatrix"] = "GS1DataMatrix";
EncodeBarcodeType2["Gs1DotCode"] = "GS1DotCode";
EncodeBarcodeType2["Gs1HanXin"] = "GS1HanXin";
EncodeBarcodeType2["Gs1MicroPdf417"] = "GS1MicroPdf417";
EncodeBarcodeType2["Gs1Qr"] = "GS1QR";
EncodeBarcodeType2["HanXin"] = "HanXin";
EncodeBarcodeType2["Iata2of5"] = "IATA2of5";
EncodeBarcodeType2["Isbn"] = "ISBN";
EncodeBarcodeType2["Ismn"] = "ISMN";
EncodeBarcodeType2["Issn"] = "ISSN";
EncodeBarcodeType2["Itf14"] = "ITF14";
EncodeBarcodeType2["Itf6"] = "ITF6";
EncodeBarcodeType2["Interleaved2of5"] = "Interleaved2of5";
EncodeBarcodeType2["ItalianPost25"] = "ItalianPost25";
EncodeBarcodeType2["Msi"] = "MSI";
EncodeBarcodeType2["MacroPdf417"] = "MacroPdf417";
EncodeBarcodeType2["Mailmark"] = "Mailmark";
EncodeBarcodeType2["Matrix2of5"] = "Matrix2of5";
EncodeBarcodeType2["MaxiCode"] = "MaxiCode";
EncodeBarcodeType2["MicroPdf417"] = "MicroPdf417";
EncodeBarcodeType2["MicroQr"] = "MicroQR";
EncodeBarcodeType2["Opc"] = "OPC";
EncodeBarcodeType2["OneCode"] = "OneCode";
EncodeBarcodeType2["Pzn"] = "PZN";
EncodeBarcodeType2["PatchCode"] = "PatchCode";
EncodeBarcodeType2["Pdf417"] = "Pdf417";
EncodeBarcodeType2["Pharmacode"] = "Pharmacode";
EncodeBarcodeType2["Planet"] = "Planet";
EncodeBarcodeType2["Postnet"] = "Postnet";
EncodeBarcodeType2["Rm4Scc"] = "RM4SCC";
EncodeBarcodeType2["RectMicroQr"] = "RectMicroQR";
EncodeBarcodeType2["Scc14"] = "SCC14";
EncodeBarcodeType2["Sscc18"] = "SSCC18";
EncodeBarcodeType2["SingaporePost"] = "SingaporePost";
EncodeBarcodeType2["Standard2of5"] = "Standard2of5";
EncodeBarcodeType2["SwissPostParcel"] = "SwissPostParcel";
EncodeBarcodeType2["Upca"] = "UPCA";
EncodeBarcodeType2["Upce"] = "UPCE";
EncodeBarcodeType2["UpcaGs1Code128Coupon"] = "UpcaGs1Code128Coupon";
EncodeBarcodeType2["UpcaGs1DatabarCoupon"] = "UpcaGs1DatabarCoupon";
EncodeBarcodeType2["Vin"] = "VIN";
return EncodeBarcodeType2;
})(EncodeBarcodeType || {});
var _EncodeData = class _EncodeData {
static getAttributeTypeMap() {
return _EncodeData.attributeTypeMap;
}
};
_EncodeData.attributeTypeMap = [
{
name: "dataType",
baseName: "dataType",
type: "EncodeDataType"
},
{
name: "data",
baseName: "data",
type: "string"
}
];
var EncodeData = _EncodeData;
var EncodeDataType = /* @__PURE__ */ ((EncodeDataType2) => {
EncodeDataType2["StringData"] = "StringData";
EncodeDataType2["Base64Bytes"] = "Base64Bytes";
EncodeDataType2["HexBytes"] = "HexBytes";
return EncodeDataType2;
})(EncodeDataType || {});
var _GenerateParams = class _GenerateParams {
static getAttributeTypeMap() {
return _GenerateParams.attributeTypeMap;
}
};
_GenerateParams.attributeTypeMap = [
{
name: "barcodeType",
baseName: "barcodeType",
type: "EncodeBarcodeType"
},
{
name: "encodeData",
baseName: "encodeData",
type: "EncodeData"
},
{
name: "barcodeImageParams",
baseName: "barcodeImageParams",
type: "BarcodeImageParams"
},
{
name: "qrParams",
baseName: "qrParams",
type: "QrParams"
},
{
name: "code128Params",
baseName: "code128Params",
type: "Code128Params"
},
{
name: "pdf417Params",
baseName: "pdf417Params",
type: "Pdf417Params"
}
];
var GenerateParams = _GenerateParams;
var GraphicsUnit = /* @__PURE__ */ ((GraphicsUnit2) => {
GraphicsUnit2["Pixel"] = "Pixel";
GraphicsUnit2["Point"] = "Point";
GraphicsUnit2["Inch"] = "Inch";
GraphicsUnit2["Millimeter"] = "Millimeter";
return GraphicsUnit2;
})(GraphicsUnit || {});
var MacroCharacter = /* @__PURE__ */ ((MacroCharacter2) => {
MacroCharacter2["None"] = "None";
MacroCharacter2["Macro05"] = "Macro05";
MacroCharacter2["Macro06"] = "Macro06";
return MacroCharacter2;
})(MacroCharacter || {});
var MicroQRVersion = /* @__PURE__ */ ((MicroQRVersion2) => {
MicroQRVersion2["Auto"] = "Auto";
MicroQRVersion2["M1"] = "M1";
MicroQRVersion2["M2"] = "M2";
MicroQRVersion2["M3"] = "M3";
MicroQRVersion2["M4"] = "M4";
return MicroQRVersion2;
})(MicroQRVersion || {});
var Pdf417EncodeMode = /* @__PURE__ */ ((Pdf417EncodeMode2) => {
Pdf417EncodeMode2["Auto"] = "Auto";
Pdf417EncodeMode2["Binary"] = "Binary";
Pdf417EncodeMode2["Eci"] = "ECI";
Pdf417EncodeMode2["Extended"] = "Extended";
return Pdf417EncodeMode2;
})(Pdf417EncodeMode || {});
var Pdf417ErrorLevel = /* @__PURE__ */ ((Pdf417ErrorLevel2) => {
Pdf417ErrorLevel2["Level0"] = "Level0";
Pdf417ErrorLevel2["Level1"] = "Level1";
Pdf417ErrorLevel2["Level2"] = "Level2";
Pdf417ErrorLevel2["Level3"] = "Level3";
Pdf417ErrorLevel2["Level4"] = "Level4";
Pdf417ErrorLevel2["Level5"] = "Level5";
Pdf417ErrorLevel2["Level6"] = "Level6";
Pdf417ErrorLevel2["Level7"] = "Level7";
Pdf417ErrorLevel2["Level8"] = "Level8";
return Pdf417ErrorLevel2;
})(Pdf417ErrorLevel || {});
var _Pdf417Params = class _Pdf417Params {
static getAttributeTypeMap() {
return _Pdf417Params.attributeTypeMap;
}
};
_Pdf417Params.attributeTypeMap = [
{
name: "pdf417EncodeMode",
baseName: "pdf417EncodeMode",
type: "Pdf417EncodeMode"
},
{
name: "pdf417ErrorLevel",
baseName: "pdf417ErrorLevel",
type: "Pdf417ErrorLevel"
},
{
name: "pdf417Truncate",
baseName: "pdf417Truncate",
type: "boolean"
},
{
name: "pdf417Columns",
baseName: "pdf417Columns",
type: "number"
},
{
name: "pdf417Rows",
baseName: "pdf417Rows",
type: "number"
},
{
name: "pdf417AspectRatio",
baseName: "pdf417AspectRatio",
type: "number"
},
{
name: "pdf417ECIEncoding",
baseName: "pdf417ECIEncoding",
type: "ECIEncodings"
},
{
name: "pdf417IsReaderInitialization",
baseName: "pdf417IsReaderInitialization",
type: "boolean"
},
{
name: "pdf417MacroCharacters",
baseName: "pdf417MacroCharacters",
type: "MacroCharacter"
},
{
name: "pdf417IsLinked",
baseName: "pdf417IsLinked",
type: "boolean"
},
{
name: "pdf417IsCode128Emulation",
baseName: "pdf417IsCode128Emulation",
type: "boolean"
}
];
var Pdf417Params = _Pdf417Params;
var QREncodeMode = /* @__PURE__ */ ((QREncodeMode2) => {
QREncodeMode2["Auto"] = "Auto";
QREncodeMode2["Extended"] = "Extended";
QREncodeMode2["Binary"] = "Binary";
QREncodeMode2["Eci"] = "ECI";
return QREncodeMode2;
})(QREncodeMode || {});
var QRErrorLevel = /* @__PURE__ */ ((QRErrorLevel2) => {
QRErrorLevel2["LevelL"] = "LevelL";
QRErrorLevel2["LevelM"] = "LevelM";
QRErrorLevel2["LevelQ"] = "LevelQ";
QRErrorLevel2["LevelH"] = "LevelH";
return QRErrorLevel2;
})(QRErrorLevel || {});
var QRVersion = /* @__PURE__ */ ((QRVersion2) => {
QRVersion2["Auto"] = "Auto";
QRVersion2["Version01"] = "Version01";
QRVersion2["Version02"] = "Version02";
QRVersion2["Version03"] = "Version03";
QRVersion2["Version04"] = "Version04";
QRVersion2["Version05"] = "Version05";
QRVersion2["Version06"] = "Version06";
QRVersion2["Version07"] = "Version07";
QRVersion2["Version08"] = "Version08";
QRVersion2["Version09"] = "Version09";
QRVersion2["Version10"] = "Version10";
QRVersion2["Version11"] = "Version11";
QRVersion2["Version12"] = "Version12";
QRVersion2["Version13"] = "Version13";
QRVersion2["Version14"] = "Version14";
QRVersion2["Version15"] = "Version15";
QRVersion2["Version16"] = "Version16";
QRVersion2["Version17"] = "Version17";
QRVersion2["Version18"] = "Version18";
QRVersion2["Version19"] = "Version19";
QRVersion2["Version20"] = "Version20";
QRVersion2["Version21"] = "Version21";
QRVersion2["Version22"] = "Version22";
QRVersion2["Version23"] = "Version23";
QRVersion2["Version24"] = "Version24";
QRVersion2["Version25"] = "Version25";
QRVersion2["Version26"] = "Version26";
QRVersion2["Version27"] = "Version27";
QRVersion2["Version28"] = "Version28";
QRVersion2["Version29"] = "Version29";
QRVersion2["Version30"] = "Version30";
QRVersion2["Version31"] = "Version31";
QRVersion2["Version32"] = "Version32";
QRVersion2["Version33"] = "Version33";
QRVersion2["Version34"] = "Version34";
QRVersion2["Version35"] = "Version35";
QRVersion2["Version36"] = "Version36";
QRVersion2["Version37"] = "Version37";
QRVersion2["Version38"] = "Version38";
QRVersion2["Version39"] = "Version39";
QRVersion2["Version40"] = "Version40";
return QRVersion2;
})(QRVersion || {});
var _QrParams = class _QrParams {
static getAttributeTypeMap() {
return _QrParams.attributeTypeMap;
}
};
_QrParams.attributeTypeMap = [
{
name: "qrEncodeMode",
baseName: "qrEncodeMode",
type: "QREncodeMode"
},
{
name: "qrErrorLevel",
baseName: "qrErrorLevel",
type: "QRErrorLevel"
},
{
name: "qrVersion",
baseName: "qrVersion",
type: "QRVersion"
},
{
name: "qrECIEncoding",
baseName: "qrECIEncoding",
type: "ECIEncodings"
},
{
name: "qrAspectRatio",
baseName: "qrAspectRatio",
type: "number"
},
{
name: "microQRVersion",
baseName: "microQRVersion",
type: "MicroQRVersion"
},
{
name: "rectMicroQrVersion",
baseName: "rectMicroQrVersion",
type: "RectMicroQRVersion"
}
];
var QrParams = _QrParams;
var RecognitionImageKind = /* @__PURE__ */ ((RecognitionImageKind2) => {
RecognitionImageKind2["Photo"] = "Photo";
RecognitionImageKind2["ScannedDocument"] = "ScannedDocument";
RecognitionImageKind2["ClearImage"] = "ClearImage";
return RecognitionImageKind2;
})(RecognitionImageKind || {});
var RecognitionMode = /* @__PURE__ */ ((RecognitionMode2) => {
RecognitionMode2["Fast"] = "Fast";
RecognitionMode2["Normal"] = "Normal";
RecognitionMode2["Excellent"] = "Excellent";
return RecognitionMode2;
})(RecognitionMode || {});
var _RecognizeBase64Request = class _RecognizeBase64Request {
static getAttributeTypeMap() {
return _RecognizeBase64Request.attributeTypeMap;
}
};
_RecognizeBase64Request.attributeTypeMap = [
{
name: "barcodeTypes",
baseName: "barcodeTypes",
type: "Array<DecodeBarcodeType>"
},
{
name: "fileBase64",
baseName: "fileBase64",
type: "string"
},
{
name: "recognitionMode",
baseName: "recognitionMode",
type: "RecognitionMode"
},
{
name: "recognitionImageKind",
baseName: "recognitionImageKind",
type: "RecognitionImageKind"
}
];
var RecognizeBase64Request = _RecognizeBase64Request;
var RectMicroQRVersion = /* @__PURE__ */ ((RectMicroQRVersion2) => {
RectMicroQRVersion2["Auto"] = "Auto";
RectMicroQRVersion2["R7x43"] = "R7x43";
RectMicroQRVersion2["R7x59"] = "R7x59";
RectMicroQRVersion2["R7x77"] = "R7x77";
RectMicroQRVersion2["R7x99"] = "R7x99";
RectMicroQRVersion2["R7x139"] = "R7x139";
RectMicroQRVersion2["R9x43"] = "R9x43";
RectMicroQRVersion2["R9x59"] = "R9x59";
RectMicroQRVersion2["R9x77"] = "R9x77";
RectMicroQRVersion2["R9x99"] = "R9x99";
RectMicroQRVersion2["R9x139"] = "R9x139";
RectMicroQRVersion2["R11x27"] = "R11x27";
RectMicroQRVersion2["R11x43"] = "R11x43";
RectMicroQRVersion2["R11x59"] = "R11x59";
RectMicroQRVersion2["R11x77"] = "R11x77";
RectMicroQRVersion2["R11x99"] = "R11x99";
RectMicroQRVersion2["R11x139"] = "R11x139";
RectMicroQRVersion2["R13x27"] = "R13x27";
RectMicroQRVersion2["R13x43"] = "R13x43";
RectMicroQRVersion2["R13x59"] = "R13x59";
RectMicroQRVersion2["R13x77"] = "R13x77";
RectMicroQRVersion2["R13x99"] = "R13x99";
RectMicroQRVersion2["R13x139"] = "R13x139";
RectMicroQRVersion2["R15x43"] = "R15x43";
RectMicroQRVersion2["R15x59"] = "R15x59";
RectMicroQRVersion2["R15x77"] = "R15x77";
RectMicroQRVersion2["R15x99"] = "R15x99";
RectMicroQRVersion2["R15x139"] = "R15x139";
RectMicroQRVersion2["R17x43"] = "R17x43";
RectMicroQRVersion2["R17x59"] = "R17x59";
RectMicroQRVersion2["R17x77"] = "R17x77";
RectMicroQRVersion2["R17x99"] = "R17x99";
RectMicroQRVersion2["R17x139"] = "R17x139";
return RectMicroQRVersion2;
})(RectMicroQRVersion || {});
var _RegionPoint = class _RegionPoint {
static getAttributeTypeMap() {
return _RegionPoint.attributeTypeMap;
}
};
_RegionPoint.attributeTypeMap = [
{
name: "x",
baseName: "x",
type: "number"
},
{
name: "y",
baseName: "y",
type: "number"
}
];
var RegionPoint = _RegionPoint;
var _ScanBase64Request = class _ScanBase64Request {
static getAttributeTypeMap() {
return _ScanBase64Request.attributeTypeMap;
}
};
_ScanBase64Request.attributeTypeMap = [
{
name: "fileBase64",
baseName: "fileBase64",
type: "string"
}
];
var ScanBase64Request = _ScanBase64Request;
var GenerateRequestWrapper = class {
/**
* @param barcodeType Type of barcode to generate.
* @param data String that represents the data to encode.
*/
constructor(barcodeType, data) {
this.barcodeType = barcodeType;
this.data = data;
}
};
var GenerateBodyRequestWrapper = class {
/**
* @param generateParams Barcode generation parameters.
*/
constructor(generateParams) {
this.generateParams = generateParams;
}
};
var GenerateMultipartRequestWrapper = class {
/**
* @param barcodeType See https://reference.aspose.com/barcode/net/aspose.barcode.generation/encodetypes/
* @param data String that represents the data to encode.
*/
constructor(barcodeType, data) {
this.barcodeType = barcodeType;
this.data = data;
}
};
var RecognizeRequestWrapper = class {
/**
* @param barcodeType Type of barcode to recognize.
* @param fileUrl URL to the barcode image.
*/
constructor(barcodeType, fileUrl) {
this.barcodeType = barcodeType;
this.fileUrl = fileUrl;
}
};
var RecognizeBase64RequestWrapper = class {
/**
* @param recognizeBase64Request Barcode recognition request.
*/
constructor(recognizeBase64Request) {
this.recognizeBase64Request = recognizeBase64Request;
}
};
var RecognizeMultipartRequestWrapper = class {
/**
* @param barcodeType See https://reference.aspose.com/barcode/net/aspose.barcode.barcoderecognition/decodetype/
* @param fileBytes Barcode image file.
*/
constructor(barcodeType, fileBytes) {
this.barcodeType = barcodeType;
this.fileBytes = fileBytes;
}
};
var ScanRequestWrapper = class {
/**
* @param fileUrl URL to the barcode image.
*/
constructor(fileUrl) {
this.fileUrl = fileUrl;
}
};
var ScanBase64RequestWrapper = class {
/**
* @param scanBase64Request Scan barcode request.
*/
constructor(scanBase64Request) {
this.scanBase64Request = scanBase64Request;
}
};
var ScanMultipartRequestWrapper = class {
/**
* @param fileBytes Barcode image file.
*/
constructor(fileBytes) {
this.fileBytes = fileBytes;
}
};
// src/api.ts
var ApiClient = class {
constructor() {
const resolvedFetch = globalThis.fetch;
if (!resolvedFetch) {
throw new Error("Global fetch API is not available. Please use Node.js 18+.");
}
this._fetcher = resolvedFetch;
}
requestAsync(options) {
const url = options.qs ? new URL(`?${new URLSearchParams(options.qs).toString()}`, options.uri) : new URL(options.uri);
const requestBody = this.buildRequestBody(options);
const responseEncoding = options.encoding === null ? null : options.encoding || "utf-8";
const requestOptions = {
method: options.method || "GET",
headers: options.headers
};
if (requestBody) {
requestOptions.body = requestBody;
}
return this.doFetchRequest(url, requestOptions, responseEncoding);
}
buildRequestBody(options) {
let requestBody = options.body;
if (options.form) {
requestBody = new URLSearchParams(options.form).toString();
options.headers = Object.assign(
{
"Content-Type": "application/x-www-form-urlencoded"
},
options.headers
);
}
if (options.json) {
requestBody = JSON.stringify(options.body);
options.headers = Object.assign(
{
"Content-Type": "application/json"
},
options.headers
);
}
return requestBody;
}
async doFetchRequest(url, requestOptions, responseEncoding) {
let response;
try {
response = await this._fetcher(url.toString(), requestOptions);
} catch (error) {
return Promise.reject({
response: null,
error: this.normalizeFetchError(error),
errorResponse: null
});
}
const respBody = await this.readResponseBody(response, responseEncoding);
const responseHeaders = this.toHeaderDict(response.headers);
const httpResponse = {
statusCode: response.status,
statusMessage: response.statusText,
headers: responseHeaders,
body: respBody
};
if (response.ok) {
return {
response: httpResponse,
body: respBody
};
}
const rejectObject = {
response: httpResponse,
error: new Error(`Error on '${url}': ${response.status} ${response.statusText}`),
errorResponse: null
};
let errorResponse = null;
try {
errorResponse = JSON.parse(respBody.toString());
} catch (parseError) {
}
if (errorResponse) {
rejectObject.errorResponse = errorResponse;
} else {
rejectObject.error.message += `. ${respBody}`;
}
return Promise.reject(rejectObject);
}
async readResponseBody(response, responseEncoding) {
const arrayBuffer = await response.arrayBuffer();
const buffer = Buffer.from(arrayBuffer);
if (responseEncoding === null) {
return buffer;
}
return buffer.toString(responseEncoding);
}
toHeaderDict(headers) {
const normalizedHeaders = {};
headers.forEach((value, key) => {
const existing = normalizedHeaders[key];
if (existing === void 0) {
normalizedHeaders[key] = value;
return;
}
if (Array.isArray(existing)) {
existing.push(value);
normalizedHeaders[key] = existing;
return;
}
normalizedHeaders[key] = [existing, value];
});
return normalizedHeaders;
}
normalizeFetchError(error) {
if (error instanceof Error) {
const mutableError = error;
let normalizedCode = mutableError.code;
if (!normalizedCode) {
const cause = mutableError.cause;
if (cause && typeof cause === "object" && "code" in cause) {
const code = cause.code;
if (code) {
normalizedCode = String(code);
}
}
}
if (!normalizedCode) {
normalizedCode = mutableError.name || "FETCH_ERROR";
}
try {
if (!mutableError.code) {
mutableError.code = normalizedCode;
}
} catch (assignError) {
}
if (mutableError.code) {
return mutableError;
}
const wrapped2 = new Error(mutableError.message);
wrapped2.name = mutableError.name;
wrapped2.code = normalizedCode;
return wrapped2;
}
const wrapped = new Error(String(error));
wrapped.code = "FETCH_ERROR";
return wrapped;
}
};
var primitives = ["string", "boolean", "double", "integer", "long", "float", "number", "any"];
var ObjectSerializer = class _ObjectSerializer {
static findCorrectType(data, expectedType) {
if (data == null) {
return expectedType;
}
if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
return expectedType;
}
if (expectedType === "Date") {
return expectedType;
}
if (enumsMap[expectedType]) {
return expectedType;
}
if (!typeMap[expectedType]) {
return expectedType;
}
let discriminatorProperty = typeMap[expectedType].discriminator;
if (discriminatorProperty == null) {
return expectedType;
}
if (data[discriminatorProperty]) {
return data[discriminatorProperty];
}
return expectedType;
}
static serialize(data, type) {
if (data == null) {
return data;
}
if (primitives.indexOf(type.toLowerCase()) !== -1) {
return data;
}
if (type.lastIndexOf("Array<", 0) === 0) {
let subType = type.replace("Array<", "");
subType = subType.substring(0, subType.length - 1);
let transformedData = [];
for (let index in data) {
let date = data[index];
transformedData.push(_ObjectSerializer.serialize(date, subType));
}
return transformedData;
}
if (type === "Date") {
return data.toString();
}
if (enumsMap[type] && Object.values(enumsMap[type]).includes(data)) {
return data;
}
if (!typeMap[type]) {
return data;
}
let attributeTypes = typeMap[type].getAttributeTypeMap();
let instance = {};
for (let index in attributeTypes) {
let attributeType = attributeTypes[index];
instance[attributeType.baseName] = _ObjectSerializer.serialize(data[attributeType.name], attributeType.type);
}
return instance;
}
static deserialize(data, type) {
type = _ObjectSerializer.findCorrectType(data, type);
if (data == null) {
return data;
}
if (primitives.indexOf(type.toLowerCase()) !== -1) {
return data;
}
if (type.lastIndexOf("Array<", 0) === 0) {
let subType = type.replace("Array<", "");
subType = subType.substring(0, subType.length - 1);
let transformedData = [];
for (let index in data) {
let date = data[index];
transformedData.push(_ObjectSerializer.deserialize(date, subType));
}
return transformedData;
}
if (type === "Date") {
return new Date(data);
}
if (enumsMap[type]) {
return data;
}
if (!typeMap[type]) {
return data;
}
if (typeof data === "string") {
data = JSON.parse(data);
}
let instance = new typeMap[type]();
let attributeTypes = typeMap[type].getAttributeTypeMap();
for (const attributeType of attributeTypes) {
const key = attributeType.baseName.replace(/^(.)/, ($1) => {
return $1.toLowerCase();
});
instance[attributeType.name] = _ObjectSerializer.deserialize(data[key], attributeType.type);
}
return instance;
}
};
var enumsMap = {
BarcodeImageFormat,
Code128EncodeMode,
CodeLocation,
DecodeBarcodeType,
ECIEncodings,
EncodeBarcodeType,
EncodeDataType,
GraphicsUnit,
MacroCharacter,
MicroQRVersion,
Pdf417EncodeMode,
Pdf417ErrorLevel,
QREncodeMode,
QRErrorLevel,
QRVersion,
RecognitionImageKind,
RecognitionMode,
RectMicroQRVersion
};
var typeMap = {
ApiError,
ApiErrorResponse,
BarcodeImageParams,
BarcodeResponse,
BarcodeResponseList,
Code128Params,
EncodeData,
GenerateParams,
Pdf417Params,
QrParams,
RecognizeBase64Request,
RegionPoint,
ScanBase64Request
};
var GenerateApi = class {
constructor(configuration) {
this.defaultHeaders = {
"x-aspose-client": "nodejs sdk",
"x-aspose-client-version": "26.6.0"
};
this._configuration = configuration;
this._client = new ApiClient();
}
/**
* Generate a barcode using a GET request with parameters in the route and query string.
* @param request GenerateRequestWrapper
*/
async generate(request) {
const requestPath = this._configuration.getApiBaseUrl() + "/barcode/generate/{barcodeType}".replace("{barcodeType}", String(request.barcodeType));
let queryParameters = {};
let headerParams = Object.assign({}, this.defaultHeaders);
if (request.barcodeType == null) {
throw new Error("Required parameter request.barcodeType was null or undefined when calling generate.");
}
if (request.data == null) {
throw new Error("Required parameter request.data was null or undefined when calling generate.");
}
if (request.dataType != null) {
queryParameters["dataType"] = ObjectSerializer.serialize(request.dataType, "EncodeDataType");
}
if (request.data != null) {
queryParameters["data"] = ObjectSerializer.serialize(request.data, "string");
}
if (request.barcodeImageParams?.imageFormat != null) {
queryParameters["imageFormat"] = ObjectSerializer.serialize(
request.barcodeImageParams.imageFormat,
"BarcodeImageFormat"
);
}
if (request.barcodeImageParams?.textLocation != null) {
queryParameters["textLocation"] = ObjectSerializer.serialize(
request.barcodeImageParams.textLocation,
"CodeLocation"
);
}
if (request.barcodeImageParams?.foregroundColor != null) {
queryParameters["foregroundColor"] = ObjectSerializer.serialize(
request.barcodeImageParams.foregroundColor,
"string"
);
}
if (request.barcodeImageParams?.backgroundColor != null) {
queryParameters["backgroundColor"] = ObjectSerializer.serialize(
request.barcodeImageParams.backgroundColor,
"string"
);
}
if (request.barcodeImageParams?.units != null) {
queryParameters["units"] = ObjectSerializer.serialize(request.barcodeImageParams.units, "GraphicsUnit");
}
if (request.barcodeImageParams?.resolution != null) {
queryParameters["resolution"] = ObjectSerializer.serialize(request.barcodeImageParams.resolution, "number");
}
if (request.barcodeImageParams?.imageHeight != null) {
queryParameters["imageHeight"] = ObjectSerializer.serialize(
request.barcodeImageParams.imageHeight,
"number"
);
}
if (request.barcodeImageParams?.imageWidth != null) {
queryParameters["imageWidth"] = ObjectSerializer.serialize(request.barcodeImageParams.imageWidth, "number");
}
if (request.barcodeImageParams?.rotationAngle != null) {
queryParameters["rotationAngle"] = ObjectSerializer.serialize(
request.barcodeImageParams.rotationAngle,
"number"
);
}
if (request.qrParams?.qrEncodeMode != null) {
queryParameters["qrEncodeMode"] = ObjectSerializer.serialize(request.qrParams.qrEncodeMode, "QREncodeMode");
}
if (request.qrParams?.qrErrorLevel != null) {
queryParameters["qrErrorLevel"] = ObjectSerializer.serialize(request.qrParams.qrErrorLevel, "QRErrorLevel");
}
if (request.qrParams?.qrVersion != null) {
queryParameters["qrVersion"] = ObjectSerializer.serialize(request.qrParams.qrVersion, "QRVersion");
}
if (request.qrParams?.qrECIEncoding != null) {
queryParameters["qrECIEncoding"] = ObjectSerializer.serialize(
request.qrParams.qrECIEncoding,
"ECIEncodings"
);
}
if (request.qrParams?.qrAspectRatio != null) {
queryParameters["qrAspectRatio"] = ObjectSerializer.serialize(request.qrParams.qrAspectRatio, "number");
}
if (request.qrParams?.microQRVersion != null) {
queryParameters["microQRVersion"] = ObjectSerializer.serialize(
request.qrParams.microQRVersion,
"MicroQRVersion"
);
}
if (request.qrParams?.rectMicroQrVersion != null) {
queryParameters["rectMicroQrVersion"] = ObjectSerializer.serialize(
request.qrParams.rectMicroQrVersion,
"RectMicroQRVersion"
);
}
if (request.code128Params?.code128EncodeMode != null) {
queryParameters["code128EncodeMode"] = ObjectSerializer.serialize(
request.code128Params.code128EncodeMode,
"Code128EncodeMode"
);
}
if (request.pdf417Params?.pdf417EncodeMode != null) {
queryParameters["pdf417EncodeMode"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417EncodeMode,
"Pdf417EncodeMode"
);
}
if (request.pdf417Params?.pdf417ErrorLevel != null) {
queryParameters["pdf417ErrorLevel"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417ErrorLevel,
"Pdf417ErrorLevel"
);
}
if (request.pdf417Params?.pdf417Truncate != null) {
queryParameters["pdf417Truncate"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417Truncate,
"boolean"
);
}
if (request.pdf417Params?.pdf417Columns != null) {
queryParameters["pdf417Columns"] = ObjectSerializer.serialize(request.pdf417Params.pdf417Columns, "number");
}
if (request.pdf417Params?.pdf417Rows != null) {
queryParameters["pdf417Rows"] = ObjectSerializer.serialize(request.pdf417Params.pdf417Rows, "number");
}
if (request.pdf417Params?.pdf417AspectRatio != null) {
queryParameters["pdf417AspectRatio"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417AspectRatio,
"number"
);
}
if (request.pdf417Params?.pdf417ECIEncoding != null) {
queryParameters["pdf417ECIEncoding"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417ECIEncoding,
"ECIEncodings"
);
}
if (request.pdf417Params?.pdf417IsReaderInitialization != null) {
queryParameters["pdf417IsReaderInitialization"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417IsReaderInitialization,
"boolean"
);
}
if (request.pdf417Params?.pdf417MacroCharacters != null) {
queryParameters["pdf417MacroCharacters"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417MacroCharacters,
"MacroCharacter"
);
}
if (request.pdf417Params?.pdf417IsLinked != null) {
queryParameters["pdf417IsLinked"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417IsLinked,
"boolean"
);
}
if (request.pdf417Params?.pdf417IsCode128Emulation != null) {
queryParameters["pdf417IsCode128Emulation"] = ObjectSerializer.serialize(
request.pdf417Params.pdf417IsCode128Emulation,
"boolean"
);
}
const requestOptions = {
method: "GET",
qs: queryParameters,
headers: headerParams,
uri: requestPath,
encoding: null
};
await this._configuration.authentication.applyToRequestAsync(requestOptions);
const result = await this._client.requestAsync(requestOptions);
return {
response: result.response,
body: ObjectSerializer.deserialize(result.body, "Buffer")
};
}
/**
* Generate a barcode using a POST request with parameters in the request body in JSON or XML format.
* @param request GenerateBodyRequestWrapper
*/
async generateBody(request) {
const requestPath = this._configuration.getApiBaseUrl() + "/barcode/generate-body";
let queryParameters = {};
let headerParams = Object.assign({}, this.defaultHeaders);
if (request.generateParams == null) {
throw new Error(
"Required parameter request.generateParams was null or undefined when calling generateBody."
);
}
const requestOptions = {
method: "POST",
qs: queryParameters,
headers: headerParams,
uri: requestPath,
body: ObjectSerializer.serialize(request.generateParams, "GenerateParams"),
json: true,
encoding: null
};
await this._configuration.authentication.applyToRequestAsync(requestOptions);
const result = await this._client.requestAsync(requestOptions);
return {
response: result.response,
body: ObjectSerializer.deserialize(result.body, "Buffer")
};
}
/**
* Generate a barcode using a POST request with parameters in a multipart form.
* @param request GenerateMultipartRequestWrapper
*/
async generateMultipart(request) {
const requestPath = this._configuration.getApiBaseUrl() + "/barcode/generate-multipart";
let queryParameters = {};
let headerParams = Object.assign({}, this.defaultHeaders);
const formParams = [];
if (request.barcodeType == null) {
throw new Error(
"Required parameter request.barcodeType was null or undefined when calling generateMultipart."
);
}
if (request.data == null) {
throw new Error("Required parameter request.data was null or undefined when calling generateMultipart.");
}
if (request.barcodeType != null) {
formParams.push(["barcodeType", ObjectSerializer.serialize(request.barcodeType, "EncodeBarcodeType")]);
}
if (request.dataType != null) {
formParams.push(["dataType", ObjectSerializer.serialize(request.dataType, "EncodeDataType")]);
}
if (request.data != null) {
formParams.push(["data", ObjectSerializer.serialize(request.data, "string")]);
}
if (request.barcodeImageParams?.imageFormat != null) {
formParams.push([
"imageFormat",
ObjectSerializer.serialize(request.barcodeImageParams.imageFormat, "BarcodeImageFormat")
]);
}
if (request.barcodeImageParams?.textLocation != null) {
formParams.push([
"textLocation",
ObjectSerializer.serialize(request.barcodeImageParams.textLocation, "CodeLocation")
]);
}
if (request.barcodeImageParams?.foregroundColor != null) {
formParams.push([
"foregroundColor",
ObjectSerializer.serialize(request.barcodeImageParams.foregroundColor, "string")
]);
}
if (request.barcodeImageParams?.backgroundColor != null) {
formParams.push([
"backgroundColor",
ObjectSerializer.serialize(request.barcodeImageParams.backgroundColor, "string")
]);
}
if (request.barcodeImageParams?.units != null) {
formParams.push(["units", ObjectSerializer.serialize(request.barcodeImageParams.units, "GraphicsUnit")]);
}
if (request.barcodeImageParams?.resolution != null) {
formParams.push([
"resolution",
ObjectSerializer.serialize(request.barcodeImageParams.resolution, "number")
]);
}
if (request.barcodeImageParams?.imageHeight != null) {
formParams.push([
"imageHeight",
ObjectSerializer.serialize(request.barcodeImageParams.imageHeight, "number")
]);
}
if (request.barcodeImageParams?.imageWidth != null) {
formParams.push([
"imageWidth",
ObjectSerializer.serialize(request.barcodeImageParams.imageWidth, "number")
]);
}
if (request.barcodeImageParams?.rotationAngle != null) {
formParams.push([
"rotationAngle",
ObjectSerializer.serialize(request.barcodeImageParams.rotationAngle, "number")
]);
}
if (request.qrParams?.qrEncodeMode != null) {
formParams.push([
"qrEncodeMode",
ObjectSerializer.serialize(request.qrParams.qrEncodeMode, "QREncodeMode")
]);
}
if (request.qrParams?.qrErrorLevel != null) {
formParams.push([
"qrErrorLevel",
ObjectSerializer.serialize(request.qrParams.qrErrorLevel, "QRErrorLevel")
]);
}
if (request.qrParams?.qrVersion != null) {
formParams.push(["qrVersion", ObjectSerializer.serialize(request.qrParams.qrVersion, "QRVersion")]);
}
if (request.qrParams?.qrECIEncoding != null) {
formParams.push([
"qrECIEncoding",
ObjectSerializer.serialize(request.qrParams.qrECIEncoding, "ECIEncodings")
]);
}
if (request.qrParams?.qrAspectRatio != null) {
formParams.push(["qrAspectRatio", ObjectSerializer.serialize(request.qrParams.qrAspectRatio, "number")]);
}
if (request.qrParams?.microQRVersion != null) {
formParams.push([
"microQRVersion",
ObjectSerializer.serialize(request.qrParams.microQRVersion, "MicroQRVersion")
]);
}
if (request.qrParams?.rectMicroQrVersion != null) {
formParams.push([
"rectMicroQrVersion",
ObjectSerializer.serialize(request.qrParams.rectMicroQrVersion, "RectMicroQRVersion")
]);
}
if (request.code128Params?.code128EncodeMode != null) {
formParams.push([
"code128EncodeMode",
ObjectSerializer.serialize(request.code128Params.code128EncodeMode, "Code128EncodeMode")
]);
}
if (request.pdf417Params?.pdf417EncodeMode != null) {
formParams.push([
"pdf417EncodeMode",
ObjectSerializer.serialize(request.pdf417Params.pdf417EncodeMode, "Pdf417EncodeMode")
]);
}
if (request.pdf417Params?.pdf417ErrorLevel != null) {
formParams.push([
"pdf417ErrorLevel",
ObjectSerializer.serialize(request.pdf417Params.pdf417ErrorLevel, "Pdf417ErrorLevel")
]);
}
if (request.pdf417Params?.pdf417Truncate != null) {
formParams.push([
"pdf417Truncate",
ObjectSerializer.serialize(request.pdf417Params.pdf417Truncate, "boolean")
]);
}
if (request.pdf417Params?.pdf417Columns != null) {
formParams.push([
"pdf417Columns",
ObjectSerializer.serialize(request.pdf417Params.pdf417Columns, "number")
]);
}
if (request.pdf417Params?.pdf417Rows != null) {
formParams.push(["pdf417Rows", ObjectSerializer.serialize(request.pdf417Params.pdf417Rows, "number")]);
}
if (request.pdf417Params?.pdf417AspectRatio != null) {
formParams.push([
"pdf417AspectRatio",