paystack-sdk 1.0.15 → 1.0.19

package/dist/subscription/interface.d.ts

@@ -0,0 +1,118 @@
+import { Authorization } from '../charge';
+import { ICustomer } from '../customer';
+import { Meta } from '../interface';
+import { IPlan } from '../plan';
+export interface CreateSubscription {
+    /**
+     * Customer's email address or customer code
+     */
+    customer: string;
+    /**
+     * Plan code
+     */
+    plan: string;
+    /**
+     * If customer has multiple authorizations, you can set the desired
+     * authorization you wish to use for this subscription here.
+     * If this is not supplied, the customer's most recent authorization would be used
+     */
+    authorization?: string;
+    /**
+     * Set the date for the first debit. (ISO 8601 format)
+     * e.g `2022-01-01T00:00:00+01:00`
+     */
+    start_date?: Date;
+}
+export interface Response {
+    status: boolean;
+    message: string;
+}
+export interface SubscriptionCreated extends Response {
+    data: {
+        customer: number;
+        plan: number;
+        integration: number;
+        domain: string;
+        start: number;
+        status: string;
+        quantity: number;
+        amount: number;
+        authorization: Authorization;
+    };
+}
+export interface ListSubscriptions extends Response {
+    data: Subscription[];
+    meta: Meta;
+}
+export interface FetchSubscription extends Response {
+    data: {
+        invoices: unknown[];
+        customer: ICustomer;
+        plan: IPlan;
+        integration: number;
+        authorization: Authorization;
+        domain: string;
+        start: number;
+        status: string;
+        quantity: number;
+        amount: number;
+        subscription_code: string;
+        email_token: string;
+        easy_cron_id: string;
+        cron_expression: string;
+        next_payment_date: Date;
+        open_invoice: string;
+        id: number;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+}
+export interface GenerateSubscriptionLink extends Response {
+    data: {
+        link: string;
+    };
+}
+export interface EnableOrDisableSubscription {
+    code: string;
+    token: string;
+}
+export interface Subscription {
+    customer: ICustomer;
+    plan: IPlan;
+    integration: number;
+    authorization: Authorization;
+    domain: string;
+    start: number;
+    status: string;
+    quantity: number;
+    amount: number;
+    subscription_code: string;
+    email_token: string;
+    easy_cron_id: string;
+    cron_expression: string;
+    next_payment_date: Date;
+    open_invoice: string;
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ListSubscriptionQueryParams {
+    /**
+     * Specify how many records you want to retrieve per page.
+     * If not specify we use a default value of 50.
+     */
+    perPage?: number;
+    /**
+     * Specify exactly what page you want to retrieve.
+     * If not specify we use a default value of 1.
+     */
+    page?: number;
+    /**
+     * Filter by Customer ID
+     */
+    customer?: number;
+    /**
+     * Filter by Plan ID
+     */
+    plan?: number;
+}

package/dist/subscription/interface.js

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

package/dist/subscription/subscription.d.ts

@@ -0,0 +1,18 @@
+import { Axios } from 'axios';
+import { CreateSubscription, EnableOrDisableSubscription, FetchSubscription, GenerateSubscriptionLink, ListSubscriptionQueryParams, ListSubscriptions, Response, SubscriptionCreated } from './interface';
+interface BadRequest {
+    status: boolean;
+    message: string;
+}
+export declare class Subscription {
+    http: Axios;
+    constructor(http: Axios);
+    create(data: CreateSubscription): Promise<SubscriptionCreated | BadRequest>;
+    list(queryParams?: ListSubscriptionQueryParams): Promise<ListSubscriptions | BadRequest>;
+    fetch(idOrCode: string): Promise<FetchSubscription | BadRequest>;
+    enable(data: EnableOrDisableSubscription): Promise<Response | BadRequest>;
+    disable(data: EnableOrDisableSubscription): Promise<Response | BadRequest>;
+    generateSubscriptionLink(code: string): Promise<GenerateSubscriptionLink | BadRequest>;
+    sendUpdateSubscriptionLink(code: string): Promise<Response | BadRequest>;
+}
+export {};

package/dist/subscription/subscription.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscription = void 0;
+class Subscription {
+    constructor(http) {
+        this.http = http;
+    }
+    create(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.http.post('/subscription', JSON.stringify(data));
+            return response;
+        });
+    }
+    list(queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get('/subscription', { params: Object.assign({}, queryParams) });
+        });
+    }
+    fetch(idOrCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`/subscription/${idOrCode}`);
+        });
+    }
+    enable(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/subscription/enable', JSON.stringify(data));
+        });
+    }
+    disable(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/subscription/disable', JSON.stringify(data));
+        });
+    }
+    generateSubscriptionLink(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`/subscription/${code}/manage/link`);
+        });
+    }
+    sendUpdateSubscriptionLink(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post(`/subscription/${code}/manage/email`);
+        });
+    }
+}
+exports.Subscription = Subscription;

package/dist/transaction/interface.d.ts

@@ -1,4 +1,5 @@
 import { Authorization, Customer } from '../charge';
+import { Meta } from '../interface';
 export interface InitializeTransaction {
     /**
      * Amount should be in **kobo** if currency
@@ -72,71 +73,83 @@ export interface InitializeTransaction {
      */
     bearer?: string;
 }
-export interface TransactionResponse {
+export interface Response {
     status: boolean;
     message: string;
-    data: TransactionInitializedOk | TransactionData | Transactions | Timeline | ExportTransaction;
-    meta?: Meta;
 }
-interface TransactionInitializedOk {
-    authorization_url: string;
-    access_code: string;
-    reference: string;
+export interface TransactionInitialized extends Response {
+    data: {
+        authorization_url: string;
+        access_code: string;
+        reference: string;
+    };
 }
-interface TransactionData {
-    amount: number;
-    currency: string;
-    transaction_date: Date;
-    status: string;
-    reference: string;
-    domain: string;
-    metadata: number;
-    gateway_response: string;
-    message?: null;
-    channel: string;
-    ip_address: string;
-    log: {
+export interface TransactionData extends Response {
+    data: {
+        amount: number;
+        currency: string;
+        transaction_date: Date;
+        status: string;
+        reference: string;
+        domain: string;
+        metadata: number;
+        gateway_response: string;
+        message?: string;
+        channel: string;
+        ip_address: string;
+        log: [
+            {
+                time_spent: number;
+                attempt: number;
+                authentication: any;
+                errors: number;
+                success: boolean;
+                mobile: boolean;
+                input: [];
+                channel: string;
+                history: [
+                    {
+                        type: string;
+                        message: string;
+                        time: number;
+                    }
+                ];
+            }
+        ];
+        fees: number;
+        authorization: Authorization;
+        customer: Customer;
+        pin: string;
+        required_amount: number;
+    };
+}
+export interface ListTransactions extends Response {
+    data: TransactionData[];
+    meta: Meta;
+}
+export interface Timeline extends Response {
+    data: {
         time_spent: number;
-        attempt: number;
+        attempts: number;
         authentication: any;
         errors: number;
         success: boolean;
         mobile: boolean;
         input: [];
-        channel: any;
-        history: {
-            type: string;
-            message: string;
-            time: number;
-        }[];
+        channel: string;
+        history: [
+            {
+                type: string;
+                message: string;
+                time: number;
+            }
+        ];
     };
-    fees: any;
-    authorization: Authorization;
-    customer: Customer;
-    pin: string;
-    required_amount: number;
 }
-interface Transactions extends TransactionData {
-}
-interface Timeline {
-    time_spent: number;
-    attempts: number;
-    authentication: any;
-    errors: number;
-    success: boolean;
-    mobile: boolean;
-    input: [];
-    channel: string;
-    history: [
-        {
-            type: string;
-            message: string;
-            time: number;
-        }
-    ];
-}
-interface ExportTransaction {
-    path: string;
+export interface ExportTransaction extends Response {
+    data: {
+        path: string;
+    };
 }
 export interface ListTransactionQueryParams {
     /**
@@ -176,13 +189,6 @@ export interface ListTransactionQueryParams {
      */
     amount?: number;
 }
-export interface Meta {
-    total: number;
-    skipped: number;
-    perPage: number;
-    page: number;
-    pageCount: number;
-}
 export interface ChargeAuthorization {
     /**
      * Amount should be in kobo if currency is `NGN`, *pesewas*,
@@ -292,4 +298,12 @@ export interface PartialDebit {
      */
     at_least: string;
 }
-export {};
+export interface PartialDebitResponse extends Response {
+    data: Record<string, any>;
+}
+export interface CheckAuthorizationResponse extends Response {
+    data: {
+        amount: string;
+        currency: string;
+    };
+}

package/dist/transaction/interface.js

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

package/dist/transaction/transaction.d.ts

@@ -1,5 +1,6 @@
 import { Axios } from 'axios';
-import { ChargeAuthorization, CheckAuthorization, InitializeTransaction, ListTransactionQueryParams, PartialDebit, TransactionResponse } from './interface';
+import { CheckAuthorizationResponse, ExportTransaction, ListTransactions, PartialDebitResponse, Timeline, TransactionData } from '.';
+import { ChargeAuthorization, CheckAuthorization, InitializeTransaction, ListTransactionQueryParams, PartialDebit, TransactionInitialized } from './interface';
 interface BadRequest {
     status: boolean;
     message: string;
@@ -17,15 +18,15 @@ export declare class Transaction {
      * Initialize a transaction
      * @param {InitializeTransaction} data **Body Param**
      */
-    initialize(data: InitializeTransaction): Promise<TransactionResponse | BadRequest>;
-    verify(reference: string): Promise<TransactionResponse | BadRequest>;
-    list(queryParams: ListTransactionQueryParams): Promise<TransactionResponse | BadRequest>;
-    fetch(id: string): Promise<TransactionResponse | BadRequest>;
-    chargeAuthorization(data: ChargeAuthorization): Promise<TransactionResponse | BadRequest>;
-    checkAuthorization(data: CheckAuthorization): Promise<TransactionResponse | BadRequest>;
-    viewTimeline(id: string): Promise<TransactionResponse | BadRequest>;
-    totals(queryParams: ListTransactionQueryParams): Promise<TransactionResponse | BadRequest>;
-    export(queryParams: ListTransactionQueryParams): Promise<TransactionResponse | BadRequest>;
-    partialDebit(data: PartialDebit): Promise<TransactionResponse | BadRequest>;
+    initialize(data: InitializeTransaction): Promise<TransactionInitialized | BadRequest>;
+    verify(reference: string): Promise<TransactionData | BadRequest>;
+    list(queryParams?: ListTransactionQueryParams): Promise<ListTransactions | BadRequest>;
+    fetch(id: string): Promise<TransactionData | BadRequest>;
+    chargeAuthorization(data: ChargeAuthorization): Promise<TransactionData | BadRequest>;
+    checkAuthorization(data: CheckAuthorization): Promise<CheckAuthorizationResponse | BadRequest>;
+    viewTimeline(id: string): Promise<Timeline | BadRequest>;
+    total(queryParams: ListTransactionQueryParams): Promise<ListTransactions | BadRequest>;
+    export(queryParams: ListTransactionQueryParams): Promise<ExportTransaction | BadRequest>;
+    partialDebit(data: PartialDebit): Promise<PartialDebitResponse | BadRequest>;
 }
 export {};

package/dist/transaction/transaction.js

@@ -26,7 +26,7 @@ class Transaction {
     initialize(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.post('/transaction/initialize', JSON.stringify(data));
-            return JSON.parse(response.data);
+            return response;
         });
     }
     verify(reference) {
@@ -34,7 +34,7 @@ class Transaction {
             const response = yield this.http.get('/transaction/verify', {
                 params: { reference },
             });
-            return JSON.parse(response.data);
+            return response;
         });
     }
     list(queryParams) {
@@ -42,47 +42,44 @@ class Transaction {
             const response = yield this.http.get('/transaction', {
                 params: Object.assign({}, queryParams),
             });
-            return JSON.parse(response.data);
+            return response;
         });
     }
     fetch(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.get(`/transaction/:${id}`);
-            return JSON.parse(response.data);
+            return response;
         });
     }
     chargeAuthorization(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.post('/transaction/charge_authorization', JSON.stringify(data));
-            return JSON.parse(response.data);
+            return response;
         });
     }
     checkAuthorization(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.post('/transaction/check_authorization', JSON.stringify(data));
-            return JSON.parse(response.data);
+            return response;
         });
     }
     viewTimeline(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.http.get(`/transaction/timeline/${id}`);
-            return JSON.parse(response.data);
+            return yield this.http.get(`/transaction/timeline/${id}`);
         });
     }
-    totals(queryParams) {
+    total(queryParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.http.get('/transaction/totals', {
+            return yield this.http.get('/transaction/totals', {
                 params: Object.assign({}, queryParams),
             });
-            return JSON.parse(response.data);
         });
     }
     export(queryParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.http.get('/transaction/export', {
+            return yield this.http.get('/transaction/export', {
                 params: Object.assign({}, queryParams),
             });
-            return JSON.parse(response.data);
         });
     }
     partialDebit(data) {

package/dist/transfer/interface.d.ts

@@ -0,0 +1,105 @@
+export interface InitiateTransfer {
+    /**
+     * Where should we transfer from? Only `balance` for now
+     */
+    source: string;
+    /** Amount to transfer in *kobo* if currency is `NGN`
+     * and *pesewas* if currency is `GHS`.
+     */
+    amount: number;
+    /**
+     * Code for transfer recipient
+     */
+    recipient: string;
+    /**
+     * The reason for the transfer
+     */
+    reason?: string;
+    /**
+     * Specify the currency of the transfer. Defaults to NGN
+     */
+    currency?: string;
+    /** If specified, the field should be a unique identifier (in lowercase)
+     * for the object. Only `-`,`_` and alphanumeric characters allowed.
+     */
+    reference?: string;
+}
+export interface Response {
+    status: boolean;
+    message: string;
+}
+export interface FinalizeTransfer extends Response {
+    data: Transfer;
+}
+export interface TransferInitiated extends Response {
+    data: Transfer;
+}
+export interface InitiateBulkTransfer {
+    /**
+     * Where should we transfer from? Only `balance` for now
+     */
+    source: string;
+    /**
+     * A list of transfer object. Each object should contain `amount`, `recipient`, and `reference`
+     */
+    transfers: {
+        amount: number;
+        recipient: string;
+        reference: string;
+    }[];
+}
+export interface BulkTransferInitiated extends Response {
+    data: Transfer[];
+}
+export interface ListTransfers extends Response {
+    data: Transfer[];
+}
+export interface FetchTransfer extends Response {
+    data: Transfer;
+}
+export interface VerifyTransfer extends Response {
+    data: Transfer;
+}
+export interface ListTransferQueryParams {
+    /**
+     * Specify how many records you want to retrieve per page.
+     * If not specify we use a default value of 50.
+     */
+    perPage?: number;
+    /**
+     * Specify exactly what page you want to retrieve.
+     * If not specify we use a default value of 1.
+     */
+    page?: number;
+    /**
+     * Specify an ID for the customer whose transactions
+     * you want to retrieve
+     */
+    customer?: number;
+    /**
+     * A timestamp from which to start listing transaction
+     * e.g `2021-10-25T00.00.05.000z`, `2021-12-25`
+     */
+    from?: Date;
+    /**
+     * A timestamp from which to stop listing transaction
+     * e.g `2021-10-25T00.00.05.000z`, `2021-12-25`
+     */
+    to?: Date;
+}
+interface Transfer {
+    integration: number;
+    domain: string;
+    amount: number;
+    source: string;
+    source_details: string;
+    reason: string;
+    recipient: number | string | Record<string, unknown>;
+    status: string;
+    failures: unknown;
+    transfer_code: string;
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export {};

package/dist/transfer/interface.js

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

package/dist/transfer/transfer.d.ts

@@ -0,0 +1,26 @@
+import { Axios } from 'axios';
+import { BulkTransferInitiated, FetchTransfer, FinalizeTransfer, InitiateBulkTransfer, InitiateTransfer, ListTransferQueryParams, ListTransfers, TransferInitiated, VerifyTransfer } from './interface';
+interface BadRequest {
+    status: boolean;
+    message: string;
+}
+export declare class Transfer {
+    http: Axios;
+    constructor(http: Axios);
+    /**
+     * # Initiate Transfer
+     * Status of transfer object returned will be `pending` if OTP is disabled.
+     * In the event that an OTP is required, status will read `otp`.
+     */
+    initiate(data: InitiateTransfer): Promise<TransferInitiated | BadRequest>;
+    /**
+     * # Finalize Transfer
+     * Finalize an initiated transfer
+     */
+    finalize(transferCode: string, otp: string): Promise<FinalizeTransfer | BadRequest>;
+    bulk(data: InitiateBulkTransfer): Promise<BulkTransferInitiated | BadRequest>;
+    list(queryParams?: ListTransferQueryParams): Promise<ListTransfers | BadRequest>;
+    fetch(idOrCode: string): Promise<FetchTransfer | BadRequest>;
+    verify(reference: string): Promise<VerifyTransfer | BadRequest>;
+}
+export {};

package/dist/transfer/transfer.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transfer = void 0;
+class Transfer {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * # Initiate Transfer
+     * Status of transfer object returned will be `pending` if OTP is disabled.
+     * In the event that an OTP is required, status will read `otp`.
+     */
+    initiate(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/transfer', JSON.stringify(data));
+        });
+    }
+    /**
+     * # Finalize Transfer
+     * Finalize an initiated transfer
+     */
+    finalize(transferCode, otp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/transfer/finalize_transfer', JSON.stringify({ transfer_code: transferCode, otp }));
+        });
+    }
+    bulk(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/transfer/bulk', JSON.stringify(data));
+        });
+    }
+    list(queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get('/transfer', {
+                params: Object.assign({}, queryParams),
+            });
+        });
+    }
+    fetch(idOrCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`/transfer/${idOrCode}`);
+        });
+    }
+    verify(reference) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`transfer/verify/${reference}`);
+        });
+    }
+}
+exports.Transfer = Transfer;