@ripwords/myinvois-client 0.0.1

package/dist/index.js

@@ -0,0 +1,523 @@
+
+//#region node_modules/destr/dist/index.mjs
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+	if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+		warnKeyDropped(key);
+		return;
+	}
+	return value;
+}
+function warnKeyDropped(key) {
+	console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+	if (typeof value !== "string") return value;
+	if (value[0] === "\"" && value[value.length - 1] === "\"" && value.indexOf("\\") === -1) return value.slice(1, -1);
+	const _value = value.trim();
+	if (_value.length <= 9) switch (_value.toLowerCase()) {
+		case "true": return true;
+		case "false": return false;
+		case "undefined": return void 0;
+		case "null": return null;
+		case "nan": return Number.NaN;
+		case "infinity": return Number.POSITIVE_INFINITY;
+		case "-infinity": return Number.NEGATIVE_INFINITY;
+	}
+	if (!JsonSigRx.test(value)) {
+		if (options.strict) throw new SyntaxError("[destr] Invalid JSON");
+		return value;
+	}
+	try {
+		if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+			if (options.strict) throw new Error("[destr] Possible prototype pollution");
+			return JSON.parse(value, jsonParseTransform);
+		}
+		return JSON.parse(value);
+	} catch (error) {
+		if (options.strict) throw error;
+		return value;
+	}
+}
+
+//#endregion
+//#region node_modules/ufo/dist/index.mjs
+const r = String.fromCharCode;
+const HASH_RE = /#/g;
+const AMPERSAND_RE = /&/g;
+const SLASH_RE = /\//g;
+const EQUAL_RE = /=/g;
+const PLUS_RE = /\+/g;
+const ENC_CARET_RE = /%5e/gi;
+const ENC_BACKTICK_RE = /%60/gi;
+const ENC_PIPE_RE = /%7c/gi;
+const ENC_SPACE_RE = /%20/gi;
+function encode(text) {
+	return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
+}
+function encodeQueryValue(input) {
+	return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
+}
+function encodeQueryKey(text) {
+	return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function decode(text = "") {
+	try {
+		return decodeURIComponent("" + text);
+	} catch {
+		return "" + text;
+	}
+}
+function decodeQueryKey(text) {
+	return decode(text.replace(PLUS_RE, " "));
+}
+function decodeQueryValue(text) {
+	return decode(text.replace(PLUS_RE, " "));
+}
+function parseQuery(parametersString = "") {
+	const object = /* @__PURE__ */ Object.create(null);
+	if (parametersString[0] === "?") parametersString = parametersString.slice(1);
+	for (const parameter of parametersString.split("&")) {
+		const s = parameter.match(/([^=]+)=?(.*)/) || [];
+		if (s.length < 2) continue;
+		const key = decodeQueryKey(s[1]);
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = decodeQueryValue(s[2] || "");
+		if (object[key] === void 0) object[key] = value;
+		else if (Array.isArray(object[key])) object[key].push(value);
+		else object[key] = [object[key], value];
+	}
+	return object;
+}
+function encodeQueryItem(key, value) {
+	if (typeof value === "number" || typeof value === "boolean") value = String(value);
+	if (!value) return encodeQueryKey(key);
+	if (Array.isArray(value)) return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
+	return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
+}
+function stringifyQuery(query) {
+	return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
+}
+const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasProtocol(inputString, opts = {}) {
+	if (typeof opts === "boolean") opts = { acceptRelative: opts };
+	if (opts.strict) return PROTOCOL_STRICT_REGEX.test(inputString);
+	return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+}
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+	}
+	const [s0, ...s] = path.split("?");
+	const cleanPath = s0.endsWith("/") ? s0.slice(0, -1) : s0;
+	return (cleanPath || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s] = path.split("?");
+	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withBase(input, base) {
+	if (isEmptyURL(base) || hasProtocol(input)) return input;
+	const _base = withoutTrailingSlash(base);
+	if (input.startsWith(_base)) return input;
+	return joinURL(_base, input);
+}
+function withQuery(input, query) {
+	const parsed = parseURL(input);
+	const mergedQuery = {
+		...parseQuery(parsed.search),
+		...query
+	};
+	parsed.search = stringifyQuery(mergedQuery);
+	return stringifyParsedURL(parsed);
+}
+function isEmptyURL(url) {
+	return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+const protocolRelative = Symbol.for("ufo:protocolRelative");
+function parseURL(input = "", defaultProto) {
+	const _specialProtoMatch = input.match(/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i);
+	if (_specialProtoMatch) {
+		const [, _proto, _pathname = ""] = _specialProtoMatch;
+		return {
+			protocol: _proto.toLowerCase(),
+			pathname: _pathname,
+			href: _proto + _pathname,
+			auth: "",
+			host: "",
+			search: "",
+			hash: ""
+		};
+	}
+	if (!hasProtocol(input, { acceptRelative: true })) return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
+	const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+	let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
+	if (protocol === "file:") path = path.replace(/\/(?=[A-Za-z]:)/, "");
+	const { pathname, search, hash } = parsePath(path);
+	return {
+		protocol: protocol.toLowerCase(),
+		auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
+		host,
+		pathname,
+		search,
+		hash,
+		[protocolRelative]: !protocol
+	};
+}
+function parsePath(input = "") {
+	const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+	return {
+		pathname,
+		search,
+		hash
+	};
+}
+function stringifyParsedURL(parsed) {
+	const pathname = parsed.pathname || "";
+	const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
+	const hash = parsed.hash || "";
+	const auth = parsed.auth ? parsed.auth + "@" : "";
+	const host = parsed.host || "";
+	const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
+	return proto + auth + host + pathname + search + hash;
+}
+
+//#endregion
+//#region node_modules/ofetch/dist/shared/ofetch.03887fc3.mjs
+var FetchError = class extends Error {
+	constructor(message, opts) {
+		super(message, opts);
+		this.name = "FetchError";
+		if (opts?.cause && !this.cause) this.cause = opts.cause;
+	}
+};
+function createFetchError(ctx) {
+	const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
+	const method = ctx.request?.method || ctx.options?.method || "GET";
+	const url = ctx.request?.url || String(ctx.request) || "/";
+	const requestStr = `[${method}] ${JSON.stringify(url)}`;
+	const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
+	const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
+	const fetchError = new FetchError(message, ctx.error ? { cause: ctx.error } : void 0);
+	for (const key of [
+		"request",
+		"options",
+		"response"
+	]) Object.defineProperty(fetchError, key, { get() {
+		return ctx[key];
+	} });
+	for (const [key, refKey] of [
+		["data", "_data"],
+		["status", "status"],
+		["statusCode", "status"],
+		["statusText", "statusText"],
+		["statusMessage", "statusText"]
+	]) Object.defineProperty(fetchError, key, { get() {
+		return ctx.response && ctx.response[refKey];
+	} });
+	return fetchError;
+}
+const payloadMethods = new Set(Object.freeze([
+	"PATCH",
+	"POST",
+	"PUT",
+	"DELETE"
+]));
+function isPayloadMethod(method = "GET") {
+	return payloadMethods.has(method.toUpperCase());
+}
+function isJSONSerializable(value) {
+	if (value === void 0) return false;
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean" || t === null) return true;
+	if (t !== "object") return false;
+	if (Array.isArray(value)) return true;
+	if (value.buffer) return false;
+	return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+const textTypes = /* @__PURE__ */ new Set([
+	"image/svg",
+	"application/xml",
+	"application/xhtml",
+	"application/html"
+]);
+const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(_contentType = "") {
+	if (!_contentType) return "json";
+	const contentType = _contentType.split(";").shift() || "";
+	if (JSON_RE.test(contentType)) return "json";
+	if (textTypes.has(contentType) || contentType.startsWith("text/")) return "text";
+	return "blob";
+}
+function resolveFetchOptions(request, input, defaults, Headers$1) {
+	const headers = mergeHeaders(input?.headers ?? request?.headers, defaults?.headers, Headers$1);
+	let query;
+	if (defaults?.query || defaults?.params || input?.params || input?.query) query = {
+		...defaults?.params,
+		...defaults?.query,
+		...input?.params,
+		...input?.query
+	};
+	return {
+		...defaults,
+		...input,
+		query,
+		params: query,
+		headers
+	};
+}
+function mergeHeaders(input, defaults, Headers$1) {
+	if (!defaults) return new Headers$1(input);
+	const headers = new Headers$1(defaults);
+	if (input) for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers$1(input)) headers.set(key, value);
+	return headers;
+}
+async function callHooks(context, hooks) {
+	if (hooks) if (Array.isArray(hooks)) for (const hook of hooks) await hook(context);
+	else await hooks(context);
+}
+const retryStatusCodes = /* @__PURE__ */ new Set([
+	408,
+	409,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const nullBodyResponses = /* @__PURE__ */ new Set([
+	101,
+	204,
+	205,
+	304
+]);
+function createFetch(globalOptions = {}) {
+	const { fetch: fetch$1 = globalThis.fetch, Headers: Headers$1 = globalThis.Headers, AbortController: AbortController$1 = globalThis.AbortController } = globalOptions;
+	async function onError(context) {
+		const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
+		if (context.options.retry !== false && !isAbort) {
+			let retries;
+			if (typeof context.options.retry === "number") retries = context.options.retry;
+			else retries = isPayloadMethod(context.options.method) ? 0 : 1;
+			const responseCode = context.response && context.response.status || 500;
+			if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
+				const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
+				if (retryDelay > 0) await new Promise((resolve) => setTimeout(resolve, retryDelay));
+				return $fetchRaw(context.request, {
+					...context.options,
+					retry: retries - 1
+				});
+			}
+		}
+		const error = createFetchError(context);
+		if (Error.captureStackTrace) Error.captureStackTrace(error, $fetchRaw);
+		throw error;
+	}
+	const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
+		const context = {
+			request: _request,
+			options: resolveFetchOptions(_request, _options, globalOptions.defaults, Headers$1),
+			response: void 0,
+			error: void 0
+		};
+		if (context.options.method) context.options.method = context.options.method.toUpperCase();
+		if (context.options.onRequest) await callHooks(context, context.options.onRequest);
+		if (typeof context.request === "string") {
+			if (context.options.baseURL) context.request = withBase(context.request, context.options.baseURL);
+			if (context.options.query) {
+				context.request = withQuery(context.request, context.options.query);
+				delete context.options.query;
+			}
+			if ("query" in context.options) delete context.options.query;
+			if ("params" in context.options) delete context.options.params;
+		}
+		if (context.options.body && isPayloadMethod(context.options.method)) {
+			if (isJSONSerializable(context.options.body)) {
+				context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
+				context.options.headers = new Headers$1(context.options.headers || {});
+				if (!context.options.headers.has("content-type")) context.options.headers.set("content-type", "application/json");
+				if (!context.options.headers.has("accept")) context.options.headers.set("accept", "application/json");
+			} else if ("pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || typeof context.options.body.pipe === "function") {
+				if (!("duplex" in context.options)) context.options.duplex = "half";
+			}
+		}
+		let abortTimeout;
+		if (!context.options.signal && context.options.timeout) {
+			const controller = new AbortController$1();
+			abortTimeout = setTimeout(() => {
+				const error = new Error("[TimeoutError]: The operation was aborted due to timeout");
+				error.name = "TimeoutError";
+				error.code = 23;
+				controller.abort(error);
+			}, context.options.timeout);
+			context.options.signal = controller.signal;
+		}
+		try {
+			context.response = await fetch$1(context.request, context.options);
+		} catch (error) {
+			context.error = error;
+			if (context.options.onRequestError) await callHooks(context, context.options.onRequestError);
+			return await onError(context);
+		} finally {
+			if (abortTimeout) clearTimeout(abortTimeout);
+		}
+		const hasBody = (context.response.body || context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
+		if (hasBody) {
+			const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
+			switch (responseType) {
+				case "json": {
+					const data = await context.response.text();
+					const parseFunction = context.options.parseResponse || destr;
+					context.response._data = parseFunction(data);
+					break;
+				}
+				case "stream": {
+					context.response._data = context.response.body || context.response._bodyInit;
+					break;
+				}
+				default: context.response._data = await context.response[responseType]();
+			}
+		}
+		if (context.options.onResponse) await callHooks(context, context.options.onResponse);
+		if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
+			if (context.options.onResponseError) await callHooks(context, context.options.onResponseError);
+			return await onError(context);
+		}
+		return context.response;
+	};
+	const $fetch = async function $fetch2(request, options) {
+		const r$1 = await $fetchRaw(request, options);
+		return r$1._data;
+	};
+	$fetch.raw = $fetchRaw;
+	$fetch.native = (...args) => fetch$1(...args);
+	$fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
+		...globalOptions,
+		...customGlobalOptions,
+		defaults: {
+			...globalOptions.defaults,
+			...customGlobalOptions.defaults,
+			...defaultOptions
+		}
+	});
+	return $fetch;
+}
+
+//#endregion
+//#region node_modules/ofetch/dist/index.mjs
+const _globalThis = function() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+	throw new Error("unable to locate global object");
+}();
+const fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
+const Headers = _globalThis.Headers;
+const AbortController = _globalThis.AbortController;
+const ofetch = createFetch({
+	fetch,
+	Headers,
+	AbortController
+});
+
+//#endregion
+//#region src/utils/MyInvoisClient.ts
+var MyInvoisClient = class {
+	baseUrl;
+	clientId;
+	clientSecret;
+	token = "";
+	tokenExpiration = new Date();
+	constructor(clientId, clientSecret, environment) {
+		this.clientId = clientId;
+		this.clientSecret = clientSecret;
+		if (environment === "sandbox") this.baseUrl = "https://preprod-mytax.hasil.gov.my/";
+		else this.baseUrl = "https://mytax.hasil.gov.my";
+	}
+	async refreshToken() {
+		const tokenResponse = await ofetch(`${this.baseUrl}/connect/token`, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: {
+				grant_type: "client_credentials",
+				client_id: this.clientId,
+				client_secret: this.clientSecret,
+				scope: "InvoicingAPI"
+			}
+		});
+		this.token = tokenResponse.access_token;
+		this.tokenExpiration = new Date(Date.now() + tokenResponse.expires_in * 1e3);
+	}
+	async getToken() {
+		if (this.tokenExpiration < new Date()) await this.refreshToken();
+		return this.token;
+	}
+	async fetch(path, options = {}) {
+		const token = await this.getToken();
+		return ofetch(`${this.baseUrl}${path}`, {
+			...options,
+			headers: {
+				...options.headers,
+				Authorization: `Bearer ${token}`
+			},
+			responseType: "json"
+		});
+	}
+	/**
+	* Validates a TIN against a NRIC
+	*
+	* @param tin
+	* @param nric
+	* @returns
+	*/
+	async verifyTin(tin, nric) {
+		try {
+			await this.fetch(`/api/v1.0/taxpayer/validate/${tin}?idType=NRIC&idValue=${nric}`, { method: "GET" });
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { MyInvoisClient };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ripwords/myinvois-client",
+  "version": "0.0.1",
+  "description": "MyInvois client",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "rolldown -c rolldown.config.ts",
+    "release": "bun run build && npm publish --access public && git push --follow-tags",
+    "lint": "oxlint",
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "oxlint": "^0.16.6",
+    "prettier": "^3.5.3",
+    "vitest": "^3.1.1",
+    "rolldown": "^1.0.0-beta.7",
+    "rolldown-plugin-dts": "^0.7.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "ofetch": "^1.4.1"
+  }
+}

package/rolldown.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'rolldown'
+import { dts } from 'rolldown-plugin-dts'
+
+export default defineConfig({
+  input: 'src/index.ts',
+  plugins: [dts()],
+  output: {
+    dir: 'dist',
+  },
+})

package/src/index.ts

@@ -0,0 +1,2 @@
+export type * from './types/index.d.ts'
+export * from './utils/MyInvoisClient'

package/src/types/classification-codes.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Represents the allowed classification codes for e-Invoice items.
+ * Based on the documentation: https://sdk.myinvois.hasil.gov.my/codes/classification-codes/
+ */
+export type ClassificationCode =
+  | '001' // Breastfeeding equipment
+  | '002' // Child care centres and kindergartens fees
+  | '003' // Computer, smartphone or tablet
+  | '004' // Consolidated e-Invoice
+  | '005' // Construction materials (as specified under Fourth Schedule of the Lembaga Pembangunan Industri Pembinaan Malaysia Act 1994)
+  | '006' // Disbursement
+  | '007' // Donation
+  | '008' // e-Commerce - e-Invoice to buyer / purchaser
+  | '009' // e-Commerce - Self-billed e-Invoice to seller, logistics, etc.
+  | '010' // Education fees
+  | '011' // Goods on consignment (Consignor)
+  | '012' // Goods on consignment (Consignee)
+  | '013' // Gym membership
+  | '014' // Insurance - Education and medical benefits
+  | '015' // Insurance - Takaful or life insurance
+  | '016' // Interest and financing expenses
+  | '017' // Internet subscription
+  | '018' // Land and building
+  | '019' // Medical examination for learning disabilities and early intervention or rehabilitation treatments of learning disabilities
+  | '020' // Medical examination or vaccination expenses
+  | '021' // Medical expenses for serious diseases
+  | '022' // Others
+  | '023' // Petroleum operations (as defined in Petroleum (Income Tax) Act 1967)
+  | '024' // Private retirement scheme or deferred annuity scheme
+  | '025' // Motor vehicle
+  | '026' // Subscription of books / journals / magazines / newspapers / other similar publications
+  | '027' // Reimbursement
+  | '028' // Rental of motor vehicle
+  | '029' // EV charging facilities (Installation, rental, sale / purchase or subscription fees)
+  | '030' // Repair and maintenance
+  | '031' // Research and development
+  | '032' // Foreign income
+  | '033' // Self-billed - Betting and gaming
+  | '034' // Self-billed - Importation of goods
+  | '035' // Self-billed - Importation of services
+  | '036' // Self-billed - Others
+  | '037' // Self-billed - Monetary payment to agents, dealers or distributors
+  | '038' // Sports equipment, rental / entry fees for sports facilities, registration in sports competition or sports training fees imposed by associations / sports clubs / companies registered with the Sports Commissioner or Companies Commission of Malaysia and carrying out sports activities as listed under the Sports Development Act 1997
+  | '039' // Supporting equipment for disabled person
+  | '040' // Voluntary contribution to approved provident fund
+  | '041' // Dental examination or treatment
+  | '042' // Fertility treatment
+  | '043' // Treatment and home care nursing, daycare centres and residential care centers
+  | '044' // Vouchers, gift cards, loyalty points, etc
+  | '045' // Self-billed - Non-monetary payment to agents, dealers or distributors
+
+/**
+ * Enum representing the allowed classification codes with descriptive names.
+ * Provides a more readable way to reference classification codes.
+ *
+ * @example
+ * const code = ClassificationCodeEnum.ComputerSmartphoneOrTablet;
+ * console.log(code); // Output: "003"
+ */
+export enum ClassificationCodeEnum {
+  BreastfeedingEquipment = '001',
+  ChildCareCentresAndKindergartensFees = '002',
+  ComputerSmartphoneOrTablet = '003',
+  ConsolidatedEInvoice = '004',
+  ConstructionMaterials = '005',
+  Disbursement = '006',
+  Donation = '007',
+  ECommerceEInvoiceToBuyer = '008',
+  ECommerceSelfBilledToSellerLogistics = '009',
+  EducationFees = '010',
+  GoodsOnConsignmentConsignor = '011',
+  GoodsOnConsignmentConsignee = '012',
+  GymMembership = '013',
+  InsuranceEducationMedicalBenefits = '014',
+  InsuranceTakafulLife = '015',
+  InterestFinancingExpenses = '016',
+  InternetSubscription = '017',
+  LandAndBuilding = '018',
+  MedicalExamLearningDisabilities = '019',
+  MedicalExamVaccination = '020',
+  MedicalExpensesSeriousDiseases = '021',
+  Others = '022',
+  PetroleumOperations = '023',
+  PrivateRetirementSchemeDeferredAnnuity = '024',
+  MotorVehicle = '025',
+  SubscriptionBooksJournalsEtc = '026',
+  Reimbursement = '027',
+  RentalOfMotorVehicle = '028',
+  EVChargingFacilities = '029',
+  RepairAndMaintenance = '030',
+  ResearchAndDevelopment = '031',
+  ForeignIncome = '032',
+  SelfBilledBettingGaming = '033',
+  SelfBilledImportationGoods = '034',
+  SelfBilledImportationServices = '035',
+  SelfBilledOthers = '036',
+  SelfBilledMonetaryPaymentToAgents = '037',
+  SportsEquipmentRentalFeesEtc = '038',
+  SupportingEquipmentDisabledPerson = '039',
+  VoluntaryContributionProvidentFund = '040',
+  DentalExamTreatment = '041',
+  FertilityTreatment = '042',
+  TreatmentHomeCareNursingEtc = '043',
+  VouchersGiftCardsLoyaltyPoints = '044',
+  SelfBilledNonMonetaryPaymentToAgents = '045',
+}
+
+/**
+ * Interface representing a classification code entry.
+ * Contains the code and its corresponding description.
+ */
+export interface Classification {
+  code: ClassificationCode
+  description: string
+}