litegate-sdk 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,23 @@
+export declare class LiteGateClient {
+    private baseUrl;
+    constructor(baseUrl?: string);
+    initiateTelebirrPayment(title: string, amount: string, buyer_phone_number: string, publicKey: string, privateKey: string): Promise<any>;
+    telebirrCallback({ notify_url, appid, notify_time, merch_code, merch_order_id, payment_order_id, total_amount, trans_currency, trade_status, trans_end_time, callback_info, sign, sign_type, transId, }: {
+        notify_url: string;
+        appid: string;
+        notify_time: string;
+        merch_code: string;
+        merch_order_id: string;
+        payment_order_id: string;
+        total_amount: string;
+        trans_currency: string;
+        trade_status: string;
+        trans_end_time: string;
+        callback_info: string;
+        sign: string;
+        sign_type: string;
+        transId: string;
+    }): Promise<any>;
+    initiateCbebirrPayment(title: string, amount: string, buyer_phone_number: string, publicKey: string, privateKey: string): Promise<any>;
+    cbebirrCallback(EncVal: string, publicKey: string, privateKey: string): Promise<any>;
+}

package/dist/client.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteGateClient = void 0;
+const signature_1 = require("./crypto/signature");
+class LiteGateClient {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl ?? "https://api.litegate.et";
+    }
+    async initiateTelebirrPayment(title, amount, buyer_phone_number, publicKey, privateKey) {
+        const body = { title, amount, buyer_phone_number };
+        const signature = await (0, signature_1.signRequest)(body, privateKey);
+        const response = await fetch(`${this.baseUrl}/v1/telebirr/initiate/`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `PublicKey ${publicKey}`,
+                "X-SIGNATURE": signature,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(JSON.stringify(err));
+        }
+        return response.json();
+    }
+    async telebirrCallback({ notify_url, appid, notify_time, merch_code, merch_order_id, payment_order_id, total_amount, trans_currency, trade_status, trans_end_time, callback_info, sign, sign_type, transId, }) {
+        const body = {
+            notify_url,
+            appid,
+            notify_time,
+            merch_code,
+            merch_order_id,
+            payment_order_id,
+            total_amount,
+            trans_currency,
+            trade_status,
+            trans_end_time,
+            callback_info,
+            sign,
+            sign_type,
+            transId,
+        };
+        const response = await fetch(`${this.baseUrl}/v1/telebirr/notify/`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(JSON.stringify(err));
+        }
+        return response.json();
+    }
+    async initiateCbebirrPayment(title, amount, buyer_phone_number, publicKey, privateKey) {
+        const body = { title, amount, buyer_phone_number };
+        const signature = await (0, signature_1.signRequest)(body, privateKey);
+        const response = await fetch(`${this.baseUrl}/v1/cbebirr/initiate/`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `PublicKey ${publicKey}`,
+                "X-SIGNATURE": signature,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(JSON.stringify(err));
+        }
+        return response.json();
+    }
+    async cbebirrCallback(EncVal, publicKey, privateKey) {
+        const body = { EncVal };
+        const signature = await (0, signature_1.signRequest)(body, privateKey);
+        const response = await fetch(`${this.baseUrl}/v1/cbebirr/notify/`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `PublicKey ${publicKey}`,
+                "X-SIGNATURE": signature,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(JSON.stringify(err));
+        }
+        return response.json();
+    }
+}
+exports.LiteGateClient = LiteGateClient;

package/dist/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/core/ApiError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/dist/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/core/ApiRequestOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/core/ApiResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/dist/core/CancelablePromise.js

@@ -0,0 +1,116 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    constructor(executor) {
+        _CancelablePromise_isResolved.set(this, void 0);
+        _CancelablePromise_isRejected.set(this, void 0);
+        _CancelablePromise_isCancelled.set(this, void 0);
+        _CancelablePromise_cancelHandlers.set(this, void 0);
+        _CancelablePromise_promise.set(this, void 0);
+        _CancelablePromise_resolve.set(this, void 0);
+        _CancelablePromise_reject.set(this, void 0);
+        __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
+        __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
+            const onResolve = (value) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_resolve, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_resolve, "f").call(this, value);
+            };
+            const onReject = (reason) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f"),
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f"),
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f"),
+            });
+            return executor(onResolve, onReject, onCancel);
+        }), "f");
+    }
+    get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
+    }
+    finally(onFinally) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
+    }
+    cancel() {
+        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
+        if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
+            try {
+                for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
+        if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+            __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}
+exports.CancelablePromise = CancelablePromise;

package/dist/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/dist/core/OpenAPI.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI = void 0;
+exports.OpenAPI = {
+    BASE: 'https://api.litegate.et',
+    VERSION: '1.0.0',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};

package/dist/core/request.d.ts

@@ -0,0 +1,34 @@
+import type { AxiosResponse, AxiosInstance } from "axios";
+import FormData from "form-data";
+import type { ApiRequestOptions } from "./ApiRequestOptions";
+import type { ApiResult } from "./ApiResult";
+import { CancelablePromise } from "./CancelablePromise";
+import type { OnCancel } from "./CancelablePromise";
+import type { OpenAPIConfig } from "./OpenAPI";
+export declare const isDefined: <T>(value: T | null | undefined) => value is Exclude<T, null | undefined>;
+export declare const isString: (value: any) => value is string;
+export declare const isStringWithValue: (value: any) => value is string;
+export declare const isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: any) => value is FormData;
+export declare const isSuccess: (status: number) => boolean;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, any>) => string;
+export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>) => Promise<T | undefined>;
+export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions, formData?: FormData) => Promise<Record<string, string>>;
+export declare const getRequestBody: (options: ApiRequestOptions) => any;
+export declare const sendRequest: <T>(config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Record<string, string>, onCancel: OnCancel, axiosClient: AxiosInstance) => Promise<AxiosResponse<T>>;
+export declare const getResponseHeader: (response: AxiosResponse<any>, responseHeader?: string) => string | undefined;
+export declare const getResponseBody: (response: AxiosResponse<any>) => any;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @param axiosClient The axios client instance to use
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions, axiosClient?: AxiosInstance) => CancelablePromise<T>;
+export {};

package/dist/core/request.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = exports.catchErrorCodes = exports.getResponseBody = exports.getResponseHeader = exports.sendRequest = exports.getRequestBody = exports.getHeaders = exports.resolve = exports.getFormData = exports.getQueryString = exports.base64 = exports.isSuccess = exports.isFormData = exports.isBlob = exports.isStringWithValue = exports.isString = exports.isDefined = void 0;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const ApiError_1 = require("./ApiError");
+const CancelablePromise_1 = require("./CancelablePromise");
+const isDefined = (value) => {
+    return value !== undefined && value !== null;
+};
+exports.isDefined = isDefined;
+const isString = (value) => {
+    return typeof value === "string";
+};
+exports.isString = isString;
+const isStringWithValue = (value) => {
+    return (0, exports.isString)(value) && value !== "";
+};
+exports.isStringWithValue = isStringWithValue;
+const isBlob = (value) => {
+    return (typeof value === "object" &&
+        typeof value.type === "string" &&
+        typeof value.stream === "function" &&
+        typeof value.arrayBuffer === "function" &&
+        typeof value.constructor === "function" &&
+        typeof value.constructor.name === "string" &&
+        /^(Blob|File)$/.test(value.constructor.name) &&
+        /^(Blob|File)$/.test(value[Symbol.toStringTag]));
+};
+exports.isBlob = isBlob;
+const isFormData = (value) => {
+    return value instanceof form_data_1.default;
+};
+exports.isFormData = isFormData;
+const isSuccess = (status) => {
+    return status >= 200 && status < 300;
+};
+exports.isSuccess = isSuccess;
+const base64 = (str) => {
+    try {
+        return btoa(str);
+    }
+    catch (err) {
+        // @ts-ignore
+        return Buffer.from(str).toString("base64");
+    }
+};
+exports.base64 = base64;
+const getQueryString = (params) => {
+    const qs = [];
+    const append = (key, value) => {
+        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    };
+    const process = (key, value) => {
+        if ((0, exports.isDefined)(value)) {
+            if (Array.isArray(value)) {
+                value.forEach((v) => {
+                    process(key, v);
+                });
+            }
+            else if (typeof value === "object") {
+                Object.entries(value).forEach(([k, v]) => {
+                    process(`${key}[${k}]`, v);
+                });
+            }
+            else {
+                append(key, value);
+            }
+        }
+    };
+    Object.entries(params).forEach(([key, value]) => {
+        process(key, value);
+    });
+    if (qs.length > 0) {
+        return `?${qs.join("&")}`;
+    }
+    return "";
+};
+exports.getQueryString = getQueryString;
+const getUrl = (config, options) => {
+    const encoder = config.ENCODE_PATH || encodeURI;
+    const path = options.url
+        .replace("{api-version}", config.VERSION)
+        .replace(/{(.*?)}/g, (substring, group) => {
+        if (options.path?.hasOwnProperty(group)) {
+            return encoder(String(options.path[group]));
+        }
+        return substring;
+    });
+    const url = `${config.BASE}${path}`;
+    if (options.query) {
+        return `${url}${(0, exports.getQueryString)(options.query)}`;
+    }
+    return url;
+};
+const getFormData = (options) => {
+    if (options.formData) {
+        const formData = new form_data_1.default();
+        const process = (key, value) => {
+            if ((0, exports.isString)(value) || (0, exports.isBlob)(value)) {
+                formData.append(key, value);
+            }
+            else {
+                formData.append(key, JSON.stringify(value));
+            }
+        };
+        Object.entries(options.formData)
+            .filter(([_, value]) => (0, exports.isDefined)(value))
+            .forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                value.forEach((v) => process(key, v));
+            }
+            else {
+                process(key, value);
+            }
+        });
+        return formData;
+    }
+    return undefined;
+};
+exports.getFormData = getFormData;
+const resolve = async (options, resolver) => {
+    if (typeof resolver === "function") {
+        return resolver(options);
+    }
+    return resolver;
+};
+exports.resolve = resolve;
+const getHeaders = async (config, options, formData) => {
+    const [token, username, password, additionalHeaders] = await Promise.all([
+        (0, exports.resolve)(options, config.TOKEN),
+        (0, exports.resolve)(options, config.USERNAME),
+        (0, exports.resolve)(options, config.PASSWORD),
+        (0, exports.resolve)(options, config.HEADERS),
+    ]);
+    const formHeaders = (typeof formData?.getHeaders === "function" && formData?.getHeaders()) ||
+        {};
+    const headers = Object.entries({
+        Accept: "application/json",
+        ...additionalHeaders,
+        ...options.headers,
+        ...formHeaders,
+    })
+        .filter(([_, value]) => (0, exports.isDefined)(value))
+        .reduce((headers, [key, value]) => ({
+        ...headers,
+        [key]: String(value),
+    }), {});
+    if ((0, exports.isStringWithValue)(token)) {
+        headers["Authorization"] = `PublicKey ${token}`;
+    }
+    if ((0, exports.isStringWithValue)(username) && (0, exports.isStringWithValue)(password)) {
+        const credentials = (0, exports.base64)(`${username}:${password}`);
+        headers["Authorization"] = `Basic ${credentials}`;
+    }
+    if (options.body !== undefined) {
+        if (options.mediaType) {
+            headers["Content-Type"] = options.mediaType;
+        }
+        else if ((0, exports.isBlob)(options.body)) {
+            headers["Content-Type"] = options.body.type || "application/octet-stream";
+        }
+        else if ((0, exports.isString)(options.body)) {
+            headers["Content-Type"] = "text/plain";
+        }
+        else if (!(0, exports.isFormData)(options.body)) {
+            headers["Content-Type"] = "application/json";
+        }
+    }
+    return headers;
+};
+exports.getHeaders = getHeaders;
+const getRequestBody = (options) => {
+    if (options.body) {
+        return options.body;
+    }
+    return undefined;
+};
+exports.getRequestBody = getRequestBody;
+const sendRequest = async (config, options, url, body, formData, headers, onCancel, axiosClient) => {
+    const source = axios_1.default.CancelToken.source();
+    const requestConfig = {
+        url,
+        headers,
+        data: body ?? formData,
+        method: options.method,
+        withCredentials: config.WITH_CREDENTIALS,
+        withXSRFToken: config.CREDENTIALS === "include" ? config.WITH_CREDENTIALS : false,
+        cancelToken: source.token,
+    };
+    onCancel(() => source.cancel("The user aborted a request."));
+    try {
+        return await axiosClient.request(requestConfig);
+    }
+    catch (error) {
+        const axiosError = error;
+        if (axiosError.response) {
+            return axiosError.response;
+        }
+        throw error;
+    }
+};
+exports.sendRequest = sendRequest;
+const getResponseHeader = (response, responseHeader) => {
+    if (responseHeader) {
+        const content = response.headers[responseHeader];
+        if ((0, exports.isString)(content)) {
+            return content;
+        }
+    }
+    return undefined;
+};
+exports.getResponseHeader = getResponseHeader;
+const getResponseBody = (response) => {
+    if (response.status !== 204) {
+        return response.data;
+    }
+    return undefined;
+};
+exports.getResponseBody = getResponseBody;
+const catchErrorCodes = (options, result) => {
+    const errors = {
+        400: "Bad Request",
+        401: "Unauthorized",
+        403: "Forbidden",
+        404: "Not Found",
+        500: "Internal Server Error",
+        502: "Bad Gateway",
+        503: "Service Unavailable",
+        ...options.errors,
+    };
+    const error = errors[result.status];
+    if (error) {
+        throw new ApiError_1.ApiError(options, result, error);
+    }
+    if (!result.ok) {
+        const errorStatus = result.status ?? "unknown";
+        const errorStatusText = result.statusText ?? "unknown";
+        const errorBody = (() => {
+            try {
+                return JSON.stringify(result.body, null, 2);
+            }
+            catch (e) {
+                return undefined;
+            }
+        })();
+        throw new ApiError_1.ApiError(options, result, `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`);
+    }
+};
+exports.catchErrorCodes = catchErrorCodes;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @param axiosClient The axios client instance to use
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+const request = (config, options, axiosClient = axios_1.default) => {
+    return new CancelablePromise_1.CancelablePromise(async (resolve, reject, onCancel) => {
+        try {
+            const url = getUrl(config, options);
+            const formData = (0, exports.getFormData)(options);
+            const body = (0, exports.getRequestBody)(options);
+            const headers = await (0, exports.getHeaders)(config, options, formData);
+            if (!onCancel.isCancelled) {
+                const response = await (0, exports.sendRequest)(config, options, url, body, formData, headers, onCancel, axiosClient);
+                const responseBody = (0, exports.getResponseBody)(response);
+                const responseHeader = (0, exports.getResponseHeader)(response, options.responseHeader);
+                const result = {
+                    url,
+                    ok: (0, exports.isSuccess)(response.status),
+                    status: response.status,
+                    statusText: response.statusText,
+                    body: responseHeader ?? responseBody,
+                };
+                (0, exports.catchErrorCodes)(options, result);
+                resolve(result.body);
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
+exports.request = request;

package/dist/crypto/signature.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalJson(data: Record<string, unknown>): string;
+export declare function signRequest(data: Record<string, unknown>, pkcs8: string): Promise<string>;

package/dist/crypto/signature.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalJson = canonicalJson;
+exports.signRequest = signRequest;
+const forge = __importStar(require("node-forge"));
+function canonicalJson(data) {
+    const sorted = Object.keys(data)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = data[key];
+        return acc;
+    }, {});
+    return JSON.stringify(sorted);
+}
+// Clean the PEM (handle both literal \n and real newlines)
+function cleanPem(pem) {
+    return pem
+        .replace(/\\n/g, "\n") // Convert literal \n to newlines if present
+        .replace(/\r\n/g, "\n") // Normalize Windows line endings
+        .trim(); // Remove extra whitespace
+}
+function parsePrivateKey(pem) {
+    // Remove headers/footers and whitespace
+    const b64 = pem
+        .replace("-----BEGIN PRIVATE KEY-----", "")
+        .replace("-----END PRIVATE KEY-----", "")
+        .replace(/\s/g, ""); // Remove ALL whitespace including newlines
+    const der = forge.util.decode64(b64);
+    const asn1 = forge.asn1.fromDer(der);
+    // Try to parse as generic private key info (PKCS#8)
+    return forge.pki.privateKeyFromAsn1(asn1);
+}
+async function signRequest(data, pkcs8) {
+    const cleanedPem = cleanPem(pkcs8);
+    const privateKey = parsePrivateKey(cleanedPem);
+    const md = forge.md.sha256.create();
+    md.update(canonicalJson(data), "utf8");
+    // Forge uses a different PSS API
+    const pss = forge.pss.create({
+        md: forge.md.sha256.create(),
+        mgf: forge.mgf.mgf1.create(forge.md.sha256.create()),
+        saltLength: 32, // or calculate max length based on key size
+    });
+    const signature = privateKey.sign(md, pss);
+    const signatureB64 = forge.util.encode64(signature);
+    return signatureB64;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { ApiError } from "./core/ApiError";
+export { CancelablePromise, CancelError } from "./core/CancelablePromise";
+export { OpenAPI } from "./core/OpenAPI";
+export type { OpenAPIConfig } from "./core/OpenAPI";
+export type { ErrorResponse } from "./models/ErrorResponse";
+export type { SuccessResponse } from "./models/SuccessResponse";
+export type { TelebirrPaymentRequest } from "./models/TelebirrPaymentRequest";
+export { TelebirrService } from "./services/TelebirrService";

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelebirrService = exports.OpenAPI = exports.CancelError = exports.CancelablePromise = exports.ApiError = void 0;
+var ApiError_1 = require("./core/ApiError");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return ApiError_1.ApiError; } });
+var CancelablePromise_1 = require("./core/CancelablePromise");
+Object.defineProperty(exports, "CancelablePromise", { enumerable: true, get: function () { return CancelablePromise_1.CancelablePromise; } });
+Object.defineProperty(exports, "CancelError", { enumerable: true, get: function () { return CancelablePromise_1.CancelError; } });
+var OpenAPI_1 = require("./core/OpenAPI");
+Object.defineProperty(exports, "OpenAPI", { enumerable: true, get: function () { return OpenAPI_1.OpenAPI; } });
+var TelebirrService_1 = require("./services/TelebirrService");
+Object.defineProperty(exports, "TelebirrService", { enumerable: true, get: function () { return TelebirrService_1.TelebirrService; } });

package/dist/models/ErrorResponse.d.ts

@@ -0,0 +1,3 @@
+export type ErrorResponse = {
+    error?: string;
+};

package/dist/models/ErrorResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/SuccessResponse.d.ts

@@ -0,0 +1,3 @@
+export type SuccessResponse = {
+    status?: string;
+};

package/dist/models/SuccessResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/TelebirrPaymentRequest.d.ts

@@ -0,0 +1,11 @@
+export type TelebirrPaymentRequest = {
+    /**
+     * Payment title or description
+     */
+    title: string;
+    /**
+     * Payment amount as a string (to preserve formatting).
+     *
+     */
+    amount: string;
+};

package/dist/models/TelebirrPaymentRequest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/TelebirrService.d.ts

@@ -0,0 +1,30 @@
+import type { SuccessResponse } from '../models/SuccessResponse';
+import type { TelebirrPaymentRequest } from '../models/TelebirrPaymentRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class TelebirrService {
+    /**
+     * Initiate Telebirr payment
+     * Initiates a Telebirr payment request.
+     *
+     * ### Signature rules
+     * - Canonical JSON:
+     * - Keys sorted alphabetically
+     * - No spaces
+     * - Algorithm: RSA-PKCS1v1.5 + SHA-256
+     * - Signature must be Base64 encoded
+     *
+     * @param authorization Client public key (base64, without PEM headers).
+     *
+     * Format:
+     * ```
+     * PublicKey MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A...
+     * ```
+     *
+     * @param xSignature Base64-encoded RSA-SHA256 signature of the canonical JSON request body.
+     *
+     * @param requestBody
+     * @returns SuccessResponse Signature valid, payment request accepted
+     * @throws ApiError
+     */
+    static telebirrInitiatePayment(authorization: string, xSignature: string, requestBody: TelebirrPaymentRequest): CancelablePromise<SuccessResponse>;
+}

package/dist/services/TelebirrService.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelebirrService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class TelebirrService {
+    /**
+     * Initiate Telebirr payment
+     * Initiates a Telebirr payment request.
+     *
+     * ### Signature rules
+     * - Canonical JSON:
+     * - Keys sorted alphabetically
+     * - No spaces
+     * - Algorithm: RSA-PKCS1v1.5 + SHA-256
+     * - Signature must be Base64 encoded
+     *
+     * @param authorization Client public key (base64, without PEM headers).
+     *
+     * Format:
+     * ```
+     * PublicKey MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A...
+     * ```
+     *
+     * @param xSignature Base64-encoded RSA-SHA256 signature of the canonical JSON request body.
+     *
+     * @param requestBody
+     * @returns SuccessResponse Signature valid, payment request accepted
+     * @throws ApiError
+     */
+    static telebirrInitiatePayment(authorization, xSignature, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/v1/telebirr/initiate-payment',
+            headers: {
+                'Authorization': authorization,
+                'X-SIGNATURE': xSignature,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid request body`,
+                401: `Invalid or missing signature / public key`,
+                403: `Telebirr service not enabled for user`,
+            },
+        });
+    }
+}
+exports.TelebirrService = TelebirrService;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "litegate-sdk",
+  "version": "1.0.0",
+  "description": "Official TypeScript SDK for LiteGate API",
+  "main": "index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@types/node-forge": "^1.3.14",
+    "axios": "^1.13.2",
+    "crypto": "^1.0.1",
+    "jose": "^6.1.3",
+    "node-forge": "^1.3.3",
+    "openapi-typescript": "^7.10.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "typescript": "^5.9.3"
+  }
+}