@instincthub/react-ui 0.1.26 → 0.1.28

package/dist/src/types/components/lib/createSubscription.d.ts

@@ -1,13 +1,145 @@
-interface SubscriptionObject {
+/**
+ * Subscription status types
+ */
+export type SubscriptionStatus = "ACTIVATED" | "PENDING" | "CANCELLED" | "EXPIRED";
+/**
+ * Subscription interval types
+ */
+export type SubscriptionInterval = "ONETIME" | "MONTHLY" | "YEARLY" | "WEEKLY";
+/**
+ * Object type containing content and object identifiers
+ */
+export interface ObjectType {
+    content_id: number;
+    object_id: string | number;
+}
+/**
+ * User data interface
+ */
+export interface UserData {
+    id: string | number;
+    email: string;
+    [key: string]: any;
+}
+/**
+ * Payment method authorization details
+ */
+export interface PaymentAuthorization {
     email?: string;
     [key: string]: any;
 }
+/**
+ * Payment method interface
+ */
+export interface PaymentMethod {
+    authorization?: PaymentAuthorization;
+    [key: string]: any;
+}
+/**
+ * Reference object interface
+ */
+export interface Reference {
+    reference: string;
+    [key: string]: any;
+}
+/**
+ * Subscription objects interface
+ */
+export interface SubscriptionObjects {
+    object_type?: ObjectType;
+    status?: SubscriptionStatus;
+    interval?: SubscriptionInterval;
+    user?: string | number | null;
+    content_type?: number;
+    object_id?: string | number;
+    reference?: string;
+    email?: string;
+    [key: string]: any;
+}
+/**
+ * Props interface for creating subscription
+ */
+export interface CreateSubscriptionProps {
+    userData?: UserData | null;
+    objects: {
+        object_type?: ObjectType;
+        [key: string]: any;
+    };
+    ref?: Reference;
+    paymentMethod?: PaymentMethod;
+}
+/**
+ * Subscription data payload
+ */
+export interface SubscriptionData {
+    status: SubscriptionStatus;
+    interval: SubscriptionInterval;
+    user: string | number | null;
+    content_type?: number;
+    object_id?: string | number;
+    reference?: string;
+    email: string;
+}
+/**
+ * API Response interface
+ */
+export interface SubscriptionResponse {
+    id?: string | number;
+    status?: string;
+    message?: string;
+    [key: string]: any;
+}
 /**
  * Creates a user subscription in the database
- * @param channel - The payment channel to use
+ *
+ * @param channel - Channel identifier
  * @param token - Authentication token
- * @param objects - Subscription details
- * @returns Promise resolving to the response or status code
+ * @param objects - Subscription objects containing payment and user details
+ * @returns Promise resolving to subscription response or status code
+ *
+ * @example
+ * ```ts
+ * const result = await createSubscription(
+ *   "my-channel",
+ *   "auth-token",
+ *   {
+ *     status: "ACTIVATED",
+ *     interval: "ONETIME",
+ *     user: userData?.id || null,
+ *     content_type: objects.object_type?.content_id,
+ *     object_id: objects.object_type?.object_id,
+ *     reference: ref?.reference,
+ *     email: paymentMethod?.authorization?.email || userData?.email
+ *   }
+ * );
+ * ```
  */
-declare const createSubscription: (channel: string, token: string, objects: SubscriptionObject) => Promise<any>;
+declare const createSubscription: (channel: string, token: string, objects: SubscriptionObjects) => Promise<SubscriptionResponse | number>;
 export default createSubscription;
+/**
+ * Type-safe wrapper for creating subscription with structured props
+ *
+ * @param channel - Channel identifier
+ * @param token - Authentication token
+ * @param props - Structured props containing userData, objects, ref, and paymentMethod
+ * @returns Promise resolving to subscription response or status code
+ *
+ * @example
+ * ```ts
+ * const result = await createSubscriptionWithProps(
+ *   "my-channel",
+ *   "auth-token",
+ *   {
+ *     userData: { id: 123, email: "user@example.com" },
+ *     objects: {
+ *       object_type: { content_id: 1, object_id: "course-123" }
+ *     },
+ *     ref: { reference: "payment-ref-123" },
+ *     paymentMethod: {
+ *       authorization: { email: "payment@example.com" }
+ *     }
+ *   }
+ * );
+ * ```
+ */
+export declare const createSubscriptionWithProps: (channel: string, token: string, props: CreateSubscriptionProps) => Promise<SubscriptionResponse | number>;

package/dist/src/types/components/lib/helpFunction.d.ts

@@ -1,4 +1,5 @@
 import React from "react";
+import { CouponType } from "@/types";
 export declare const IN_DEV_MODE: boolean;
 export declare const API_HOST_URL: string;
 export declare const FILE_URL: string;
@@ -56,6 +57,17 @@ export declare const calculateAmountAfterDeduction: (amount: number, percentage:
     amount: number;
     detail?: string | undefined;
 };
+/**
+ * Calculates amount after percentage deduction.
+ * @param amount Base amount
+ * @param coupon CouponType object
+ * @returns Object with final amount or error details
+ */
+export declare const calculateCouponDeduction: (amount: number, currency: string, coupon: CouponType) => {
+    amount: number;
+    detail?: string | undefined;
+    discounted: boolean;
+};
 /**
  * Finds keys in an object that are null, undefined, or empty string.
  * @param namesArray Array of keys to check
@@ -288,7 +300,7 @@ export declare const fetchAPI: <T>(session: {
         status?: number | undefined;
         error?: any;
     }) => void;
-} | ((data: T) => void), api: string, reqOptions: RequestOptions, isFunctionComponent?: boolean, setIsLoading?: ((loading: boolean) => void) | null | undefined, setStatus?: ((status: number | null) => void) | null | undefined, setError?: ((error: any) => void) | null | undefined, flag?: boolean) => Promise<T | Error>;
+} | ((data: T) => void), api: string, reqOptions: RequestOptions, isFunctionComponent?: boolean, setIsLoading?: ((loading: boolean) => void) | null | undefined, setStatus?: ((status: number | null) => void) | null | undefined, setError?: ((error: any) => void) | null | undefined, flag?: boolean) => Promise<Error | T>;
 /**
  * Handles HTTP status errors with navigation.
  * @param status HTTP status code

package/dist/src/types/components/lib/paystack.d.ts

@@ -77,6 +77,44 @@ export declare const payWithPaystack: (config: PaystackConfigType) => Promise<Pa
  * @context This function orchestrates the entire payment flow from confirmation to processing
  */
 export declare function handlePaymentSubmit(contexts: PaymentContextType): Promise<void>;
+/**
+ * Handles payment submission without requiring user data upfront
+ * Useful for guest checkout or anonymous payments
+ * @example
+ * ```ts
+ * handlePaymentWithoutUserData({
+ *   amount: 5000,
+ *   label: "Course Enrollment",
+ *   currency: "NGN",
+ *   metadata: {
+ *     content_type: "course",
+ *     object_id: "123",
+ *   },
+ *   handleDBAction: (data: any) => {
+ *     console.log(data);
+ *   },
+ *   setStatus: (status: number) => {
+ *     console.log(status);
+ *   },
+ * });
+ * ```
+ * @param config - Minimal payment configuration without user details
+ */
+export declare function handlePaymentWithoutUserData(config: {
+    amount: number;
+    label: string;
+    currency?: string;
+    metadata?: PaystackConfigObjectType["metadata"];
+    handleDBAction: (data?: any) => void;
+    setStatus: (status: number) => void;
+    coupon?: string;
+    gatwayCharges?: number;
+    defaultConfirm?: boolean;
+    defaultMsg?: string;
+    e?: Event | null;
+    content_type?: string | number;
+    object_id?: string | number;
+}): Promise<void>;
 declare global {
     interface Window {
         PaystackPop: {

package/dist/src/types/components/lib/redux/createAppAsyncThunk.d.ts

@@ -12,16 +12,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
     fulfilledMeta?: unknown;
     rejectedMeta?: unknown;
 }> & {
-    withTypes<ThunkApiConfig extends {
-        state?: unknown;
-        dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-        extra?: unknown;
-        rejectValue?: unknown;
-        serializedErrorType?: unknown;
-        pendingMeta?: unknown;
-        fulfilledMeta?: unknown;
-        rejectedMeta?: unknown;
-    }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig & Omit<{
+    withTypes<ThunkApiConfig extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig & Omit<{
         state: ReduxState;
         dispatch: ReduxDispatch;
         rejectValue: string;
@@ -40,16 +31,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
         fulfilledMeta?: unknown;
         rejectedMeta?: unknown;
     }, keyof ThunkApiConfig>)[K]; } : never> & {
-        withTypes<ThunkApiConfig_1 extends {
-            state?: unknown;
-            dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-            extra?: unknown;
-            rejectValue?: unknown;
-            serializedErrorType?: unknown;
-            pendingMeta?: unknown;
-            fulfilledMeta?: unknown;
-            rejectedMeta?: unknown;
-        }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+        withTypes<ThunkApiConfig_1 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
             state: ReduxState;
             dispatch: ReduxDispatch;
             rejectValue: string;
@@ -86,16 +68,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
             fulfilledMeta?: unknown;
             rejectedMeta?: unknown;
         }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never> & {
-            withTypes<ThunkApiConfig_2 extends {
-                state?: unknown;
-                dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                extra?: unknown;
-                rejectValue?: unknown;
-                serializedErrorType?: unknown;
-                pendingMeta?: unknown;
-                fulfilledMeta?: unknown;
-                rejectedMeta?: unknown;
-            }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+            withTypes<ThunkApiConfig_2 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                 state: ReduxState;
                 dispatch: ReduxDispatch;
                 rejectValue: string;
@@ -168,16 +141,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                 fulfilledMeta?: unknown;
                 rejectedMeta?: unknown;
             }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never> & {
-                withTypes<ThunkApiConfig_3 extends {
-                    state?: unknown;
-                    dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                    extra?: unknown;
-                    rejectValue?: unknown;
-                    serializedErrorType?: unknown;
-                    pendingMeta?: unknown;
-                    fulfilledMeta?: unknown;
-                    rejectedMeta?: unknown;
-                }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                withTypes<ThunkApiConfig_3 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                     state: ReduxState;
                     dispatch: ReduxDispatch;
                     rejectValue: string;
@@ -322,16 +286,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                     fulfilledMeta?: unknown;
                     rejectedMeta?: unknown;
                 }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never> & {
-                    withTypes<ThunkApiConfig_4 extends {
-                        state?: unknown;
-                        dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                        extra?: unknown;
-                        rejectValue?: unknown;
-                        serializedErrorType?: unknown;
-                        pendingMeta?: unknown;
-                        fulfilledMeta?: unknown;
-                        rejectedMeta?: unknown;
-                    }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                    withTypes<ThunkApiConfig_4 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                         state: ReduxState;
                         dispatch: ReduxDispatch;
                         rejectValue: string;
@@ -620,16 +575,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                         fulfilledMeta?: unknown;
                         rejectedMeta?: unknown;
                     }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never, keyof ThunkApiConfig_4>)[K_4]; } : never> & {
-                        withTypes<ThunkApiConfig_5 extends {
-                            state?: unknown;
-                            dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                            extra?: unknown;
-                            rejectValue?: unknown;
-                            serializedErrorType?: unknown;
-                            pendingMeta?: unknown;
-                            fulfilledMeta?: unknown;
-                            rejectedMeta?: unknown;
-                        }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                        withTypes<ThunkApiConfig_5 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                             state: ReduxState;
                             dispatch: ReduxDispatch;
                             rejectValue: string;
@@ -1206,16 +1152,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                             fulfilledMeta?: unknown;
                             rejectedMeta?: unknown;
                         }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never, keyof ThunkApiConfig_4>)[K_4]; } : never, keyof ThunkApiConfig_5>)[K_5]; } : never> & {
-                            withTypes<ThunkApiConfig_6 extends {
-                                state?: unknown;
-                                dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                                extra?: unknown;
-                                rejectValue?: unknown;
-                                serializedErrorType?: unknown;
-                                pendingMeta?: unknown;
-                                fulfilledMeta?: unknown;
-                                rejectedMeta?: unknown;
-                            }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                            withTypes<ThunkApiConfig_6 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                                 state: ReduxState;
                                 dispatch: ReduxDispatch;
                                 rejectValue: string;
@@ -2368,16 +2305,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                                 fulfilledMeta?: unknown;
                                 rejectedMeta?: unknown;
                             }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never, keyof ThunkApiConfig_4>)[K_4]; } : never, keyof ThunkApiConfig_5>)[K_5]; } : never, keyof ThunkApiConfig_6>)[K_6]; } : never> & {
-                                withTypes<ThunkApiConfig_7 extends {
-                                    state?: unknown;
-                                    dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                                    extra?: unknown;
-                                    rejectValue?: unknown;
-                                    serializedErrorType?: unknown;
-                                    pendingMeta?: unknown;
-                                    fulfilledMeta?: unknown;
-                                    rejectedMeta?: unknown;
-                                }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                                withTypes<ThunkApiConfig_7 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                                     state: ReduxState;
                                     dispatch: ReduxDispatch;
                                     rejectValue: string;
@@ -4682,16 +4610,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                                     fulfilledMeta?: unknown;
                                     rejectedMeta?: unknown;
                                 }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never, keyof ThunkApiConfig_4>)[K_4]; } : never, keyof ThunkApiConfig_5>)[K_5]; } : never, keyof ThunkApiConfig_6>)[K_6]; } : never, keyof ThunkApiConfig_7>)[K_7]; } : never> & {
-                                    withTypes<ThunkApiConfig_8 extends {
-                                        state?: unknown;
-                                        dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                                        extra?: unknown;
-                                        rejectValue?: unknown;
-                                        serializedErrorType?: unknown;
-                                        pendingMeta?: unknown;
-                                        fulfilledMeta?: unknown;
-                                        rejectedMeta?: unknown;
-                                    }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                                    withTypes<ThunkApiConfig_8 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                                         state: ReduxState;
                                         dispatch: ReduxDispatch;
                                         rejectValue: string;
@@ -9300,16 +9219,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                                         fulfilledMeta?: unknown;
                                         rejectedMeta?: unknown;
                                     }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never, keyof ThunkApiConfig_4>)[K_4]; } : never, keyof ThunkApiConfig_5>)[K_5]; } : never, keyof ThunkApiConfig_6>)[K_6]; } : never, keyof ThunkApiConfig_7>)[K_7]; } : never, keyof ThunkApiConfig_8>)[K_8]; } : never> & {
-                                        withTypes<ThunkApiConfig_9 extends {
-                                            state?: unknown;
-                                            dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                                            extra?: unknown;
-                                            rejectValue?: unknown;
-                                            serializedErrorType?: unknown;
-                                            pendingMeta?: unknown;
-                                            fulfilledMeta?: unknown;
-                                            rejectedMeta?: unknown;
-                                        }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_9 & Omit<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                                        withTypes<ThunkApiConfig_9 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_9 & Omit<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                                             state: ReduxState;
                                             dispatch: ReduxDispatch;
                                             rejectValue: string;
@@ -18526,16 +18436,7 @@ export declare const createAppAsyncThunk: import("@reduxjs/toolkit").CreateAsync
                                             fulfilledMeta?: unknown;
                                             rejectedMeta?: unknown;
                                         }, keyof ThunkApiConfig>)[K]; } : never, keyof ThunkApiConfig_1>)[K_1]; } : never, keyof ThunkApiConfig_2>)[K_2]; } : never, keyof ThunkApiConfig_3>)[K_3]; } : never, keyof ThunkApiConfig_4>)[K_4]; } : never, keyof ThunkApiConfig_5>)[K_5]; } : never, keyof ThunkApiConfig_6>)[K_6]; } : never, keyof ThunkApiConfig_7>)[K_7]; } : never, keyof ThunkApiConfig_8>)[K_8]; } : never, keyof ThunkApiConfig_9>)[K_9]; } : never> & {
-                                            withTypes<ThunkApiConfig_10 extends {
-                                                state?: unknown;
-                                                dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction> | undefined;
-                                                extra?: unknown;
-                                                rejectValue?: unknown;
-                                                serializedErrorType?: unknown;
-                                                pendingMeta?: unknown;
-                                                fulfilledMeta?: unknown;
-                                                rejectedMeta?: unknown;
-                                            }>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_10 & Omit<ThunkApiConfig_9 & Omit<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
+                                            withTypes<ThunkApiConfig_10 extends import("@reduxjs/toolkit").AsyncThunkConfig>(): import("@reduxjs/toolkit").CreateAsyncThunkFunction<ThunkApiConfig_10 & Omit<ThunkApiConfig_9 & Omit<ThunkApiConfig_8 & Omit<ThunkApiConfig_7 & Omit<ThunkApiConfig_6 & Omit<ThunkApiConfig_5 & Omit<ThunkApiConfig_4 & Omit<ThunkApiConfig_3 & Omit<ThunkApiConfig_2 & Omit<ThunkApiConfig_1 & Omit<ThunkApiConfig & Omit<{
                                                 state: ReduxState;
                                                 dispatch: ReduxDispatch;
                                                 rejectValue: string;

package/dist/src/types/components/tests/calculate_coupon.d.ts

@@ -0,0 +1,29 @@
+declare const couponObj: {
+    id: number;
+    total_claimed_coupon: number;
+    content_objects: {
+        id: number;
+        uuid: string;
+        slug: string;
+        title: string;
+        privacy: string;
+        timestamp: string;
+        reward_option: string;
+        content_type_id: number;
+    };
+    code: string;
+    email_list: string;
+    object_id: string;
+    valid_from: string;
+    valid_to: string;
+    days_count: number;
+    discount_type: string;
+    discount: number;
+    amount: null;
+    currency: string;
+    active: boolean;
+    timestamp: string;
+    channel: string;
+    content_type: number;
+    students: never[];
+};

package/dist/src/types/types/index.d.ts

@@ -448,6 +448,8 @@ export interface PaystackConfigType {
     metadata?: PaystackMetadataType;
 }
 export interface PaystackResponseType {
+    email: string;
+    amount: number;
     status: string;
     reference: string;
     message?: string;

package/dist/src/types/types/payments.d.ts

@@ -1 +1,33 @@
 export type PaymentStatusType = "unpaid" | "paid" | "overdue" | "partially_paid" | "refunded" | "failed" | "pending" | "in_progress" | "canceled" | "expired" | "voided";
+export interface CouponType {
+    id: number;
+    total_claimed_coupon?: number;
+    content_objects?: CouponContentObjectType;
+    code: string;
+    email_list: string;
+    object_id: string;
+    valid_from: string;
+    valid_to: string;
+    days_count: number;
+    discount_type: "percentage" | "amount" | null;
+    discount: number;
+    amount: number;
+    currency: "NGN" | "USD" | "EUR" | string;
+    active: boolean;
+    timestamp: string;
+    channel: string;
+    content_type: number;
+    students: any[];
+    details?: string;
+    [key: string]: any;
+}
+export interface CouponContentObjectType {
+    id: number;
+    uuid: string;
+    slug: string;
+    title: string;
+    privacy: string;
+    timestamp: string;
+    issue_certificate: boolean;
+    content_type_id: number;
+}