react-redux-django-auth 1.4.5 → 1.4.7

package/dist/auth-native/storage/nativeStorage.js

@@ -0,0 +1,111 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import * as Keychain from 'react-native-keychain';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+var ACCESS_KEY = 'access';
+export var storage = {
+    /**
+     * 🔑 Access token (fast access)
+     */
+    getAccessToken: function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, AsyncStorage.getItem(ACCESS_KEY)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); },
+    /**
+     * 🔁 Refresh token (SECURED with biometrics)
+     */
+    getRefreshToken: function () { return __awaiter(void 0, void 0, void 0, function () {
+        var credentials;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Keychain.getGenericPassword({
+                        authenticationPrompt: {
+                            title: 'Authenticate to continue',
+                        },
+                    })];
+                case 1:
+                    credentials = _a.sent();
+                    if (!credentials)
+                        return [2 /*return*/, null];
+                    return [2 /*return*/, credentials.password]; // refresh token
+            }
+        });
+    }); },
+    /**
+     * 💾 Save tokens
+     */
+    setTokens: function (access, refresh) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, AsyncStorage.setItem(ACCESS_KEY, access)];
+                case 1:
+                    _a.sent();
+                    if (!refresh) return [3 /*break*/, 3];
+                    return [4 /*yield*/, Keychain.setGenericPassword('refreshToken', // username (not important)
+                        refresh, {
+                            accessControl: Keychain.ACCESS_CONTROL.BIOMETRY_ANY_OR_DEVICE_PASSCODE,
+                            accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED,
+                            //   authenticationType: Keychain.AUTHENTICATION_TYPE.BIOMETRICS,
+                        })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); },
+    /**
+     * 🧹 Clear tokens
+     */
+    clearTokens: function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, AsyncStorage.removeItem(ACCESS_KEY)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, Keychain.resetGenericPassword()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); },
+};

package/dist/auth-native/store.d.ts

@@ -0,0 +1,8 @@
+declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    auth: import("../auth-core/reducers/authReducer").AuthState;
+}, any, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        auth: import("../auth-core/reducers/authReducer").AuthState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export default store;

package/dist/auth-native/store.js

@@ -0,0 +1,9 @@
+import { configureStore } from '@reduxjs/toolkit';
+import rootReducer from '../auth-core/reducers';
+var initialState = {};
+var store = configureStore({
+    reducer: rootReducer,
+    // If you want to set an initial state, use preloadedState instead:
+    preloadedState: initialState,
+});
+export default store;

package/dist/auth-web/authProvider.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+type AuthProviderProps = {
+    children: React.ReactNode;
+    apiUrl: string;
+};
+declare const AuthProvider: React.FC<AuthProviderProps>;
+export default AuthProvider;

package/dist/auth-web/authProvider.js

@@ -0,0 +1,14 @@
+import React, { useEffect } from "react";
+import { Provider } from "react-redux";
+import store from "../auth-native/store";
+import { auth } from "./index";
+import { setBaseURL } from "../auth-core/apis/config";
+var AuthProvider = function (_a) {
+    var children = _a.children, apiUrl = _a.apiUrl;
+    useEffect(function () {
+        setBaseURL(apiUrl);
+        auth.initialize(); // 🔥 attach token to axios on app load
+    }, [apiUrl]);
+    return React.createElement(Provider, { store: store }, children);
+};
+export default AuthProvider;

package/dist/auth-web/hooks/useGoogleAuth.d.ts

@@ -0,0 +1,11 @@
+import { AuthStorage } from "../../auth-core/actions/types";
+interface GoogleAuthHookReturn {
+    continueWithGoogle: () => Promise<void>;
+    authenticateWithGoogle: (state: string, code: string) => Promise<void>;
+    isAuthenticated: boolean | null;
+    error: any;
+    isStatus201: boolean;
+    loading: boolean;
+}
+declare const useGoogleAuth: (storage: AuthStorage) => GoogleAuthHookReturn;
+export default useGoogleAuth;

package/dist/auth-web/hooks/useGoogleAuth.js

@@ -0,0 +1,126 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { useDispatch, useSelector } from "react-redux";
+import { useEffect, useCallback, useState } from "react";
+import { clearErrors } from "../../auth-core/actions/authActions";
+import axios from "axios";
+import { googleAuthenticate } from "../oauth/google";
+import { getBaseURL } from "../../auth-core/apis/config";
+// The custom hook is now typed with its parameters and return value
+var useGoogleAuth = function (storage) {
+    // useDispatch is typed with our custom AppDispatch
+    var dispatch = useDispatch();
+    // useSelector is typed with AuthState for type-safe state access
+    var isAuthenticated = useSelector(function (state) { return state.auth.isAuthenticated; });
+    var error = useSelector(function (state) { return state.auth.error; });
+    var status = useSelector(function (state) { return state.auth.status; });
+    // useState is typed as boolean
+    var _a = useState(false), loading = _a[0], setLoading = _a[1];
+    var isStatus201 = status === 201;
+    // Initiate Google Login
+    var continueWithGoogle = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var redirectUri, res, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setLoading(true);
+                    redirectUri = "".concat(window.location.origin, "/login");
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    return [4 /*yield*/, axios.get("".concat(getBaseURL(), "/auth/o/google-oauth2/?redirect_uri=").concat(redirectUri))];
+                case 2:
+                    res = _a.sent();
+                    // Redirect user to Google's OAuth page
+                    window.location.replace(res.data.authorization_url);
+                    return [3 /*break*/, 5];
+                case 3:
+                    err_1 = _a.sent();
+                    console.error("Google Auth Failed", err_1);
+                    return [3 /*break*/, 5];
+                case 4:
+                    setLoading(false);
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, []);
+    // Authenticate with Google after redirection
+    var authenticateWithGoogle = useCallback(function (state, code) { return __awaiter(void 0, void 0, void 0, function () {
+        var err_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!state || !code)
+                        return [2 /*return*/];
+                    setLoading(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    return [4 /*yield*/, dispatch(googleAuthenticate(state, code, storage))];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 3:
+                    err_2 = _a.sent();
+                    console.error("Authentication failed", err_2);
+                    return [3 /*break*/, 5];
+                case 4:
+                    setLoading(false);
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [dispatch, storage]);
+    // Clear errors when the hook is unmounted
+    useEffect(function () {
+        // Clear errors when the component mounts
+        dispatch(clearErrors());
+        return function () {
+            dispatch(clearErrors());
+        };
+    }, [dispatch]);
+    return {
+        continueWithGoogle: continueWithGoogle,
+        authenticateWithGoogle: authenticateWithGoogle,
+        isAuthenticated: isAuthenticated,
+        error: error,
+        isStatus201: isStatus201,
+        loading: loading,
+    };
+};
+export default useGoogleAuth;

package/dist/auth-web/index.d.ts

@@ -0,0 +1,6 @@
+export declare const auth: {
+    initialize: () => void;
+};
+export { default as AuthProvider } from "./authProvider";
+export { default as store } from "./store";
+export { default as useGoogleAuth } from "./hooks/useGoogleAuth";

package/dist/auth-web/index.js

@@ -0,0 +1,6 @@
+import { setupAuth } from "../auth-core/setup/setupAuth";
+import { storage } from "./storage/webStorage";
+export var auth = setupAuth(storage);
+export { default as AuthProvider } from "./authProvider";
+export { default as store } from "./store";
+export { default as useGoogleAuth } from "./hooks/useGoogleAuth";

package/dist/auth-web/oauth/google.d.ts

@@ -0,0 +1,3 @@
+import { AppDispatch } from '../../auth-core/actions/authActions';
+import { AuthStorage } from '../../auth-core/actions/types';
+export declare const googleAuthenticate: (state: any, code: any, storage: AuthStorage) => (dispatch: AppDispatch) => Promise<void>;

package/dist/auth-web/oauth/google.js

@@ -0,0 +1,93 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import axios from 'axios';
+import { load_user } from '../../auth-core/actions/authActions';
+import { GOOGLE_AUTH_FAIL, GOOGLE_AUTH_SUCCESS, } from '../../auth-core/actions/types';
+import { getBaseURL } from '../../auth-core/apis/config';
+export var googleAuthenticate = function (state, code, storage) { return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+    var config, details_1, formBody, res, err_1, error;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(state && code && !localStorage.getItem('access'))) return [3 /*break*/, 4];
+                config = {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded'
+                    }
+                };
+                details_1 = {
+                    'state': state,
+                    'code': code
+                };
+                formBody = Object.keys(details_1).map(function (key) { return encodeURIComponent(key) + '=' + encodeURIComponent(details_1[key]); }).join('&');
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/o/google-oauth2/?").concat(formBody), config)];
+            case 2:
+                res = _a.sent();
+                dispatch({
+                    type: GOOGLE_AUTH_SUCCESS,
+                    payload: __assign(__assign({}, res.data), { status: res.status })
+                });
+                dispatch(load_user(storage));
+                return [3 /*break*/, 4];
+            case 3:
+                err_1 = _a.sent();
+                error = err_1;
+                if (error.response) {
+                    dispatch({
+                        type: GOOGLE_AUTH_FAIL,
+                        payload: error.response.data
+                    });
+                }
+                return [3 /*break*/, 4];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); }; };

package/dist/auth-web/storage/webStorage.d.ts

@@ -0,0 +1,5 @@
+export declare const storage: {
+    getAccessToken: () => string | null;
+    setTokens: (access: string, refresh?: string) => void;
+    clearTokens: () => void;
+};

package/dist/auth-web/storage/webStorage.js

@@ -0,0 +1,13 @@
+export var storage = {
+    getAccessToken: function () { return localStorage.getItem('access'); },
+    setTokens: function (access, refresh) {
+        localStorage.setItem('access', access);
+        if (refresh) {
+            localStorage.setItem('refresh', refresh);
+        }
+    },
+    clearTokens: function () {
+        localStorage.removeItem('access');
+        localStorage.removeItem('refresh');
+    }
+};

package/dist/auth-web/store.d.ts

@@ -0,0 +1,8 @@
+declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    auth: import("../auth-core/reducers/authReducer").AuthState;
+}, any, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        auth: import("../auth-core/reducers/authReducer").AuthState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export default store;

package/dist/auth-web/store.js

@@ -0,0 +1,9 @@
+import { configureStore } from '@reduxjs/toolkit';
+import rootReducer from '../auth-core/reducers';
+var initialState = {};
+var store = configureStore({
+    reducer: rootReducer,
+    // If you want to set an initial state, use preloadedState instead:
+    preloadedState: initialState,
+});
+export default store;

package/dist/index.d.mts

@@ -1,150 +1,31 @@
-import React$1 from 'react';
+import React from 'react';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux_thunk from 'redux-thunk';
+import * as redux from 'redux';
 
-interface ActivateHookReturn {
-    loading: boolean;
-    error: any;
-    onSubmit: (e: React.FormEvent) => Promise<void>;
-    status: any;
-    isStatus204: boolean;
-}
-declare const useActivate: (uid: string, token: string, apiUrl: string) => ActivateHookReturn;
+declare const AuthProviderNative: ({ children }: any) => React.JSX.Element;
 
-interface LoginHookReturn {
-    loading: boolean;
-    formData: any;
-    error: any;
-    currentUser: any;
-    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
-    onSubmit: (e: React.FormEvent) => Promise<void>;
-    isAuthenticated: boolean | null;
-    isStatus200: boolean;
-}
-declare const useLogin: (initialFields: any, apiUrl: string, location: any) => LoginHookReturn;
-
-declare const useLogout: () => (() => void);
-
-interface SignupHookReturn {
-    loading: boolean;
-    formData: any;
-    error: any;
-    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
-    onSubmit: (e: React.FormEvent) => Promise<void>;
+interface AuthState {
+    access: string | null;
+    refresh: string | null;
     isAuthenticated: boolean | null;
-    status: any;
-    isStatus201: boolean;
-}
-declare const useSignup: (initialFields: any, apiUrl: string, location: any) => SignupHookReturn;
-
-interface AuthHookReturn {
-    error: any;
-    isAuthenticated: boolean | null;
-    currentUser: any;
-    clearErrors: () => void;
-    refreshUser: () => void;
-    refreshAuth: () => Promise<void>;
-    isLoading: boolean;
-}
-declare const useAuthicatedUser: (apiURL: string, location: any) => AuthHookReturn;
-
-interface ResetPasswordHookReturn {
-    email: string;
-    loading: boolean;
-    handleChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
-    status: any;
+    user: any;
     error: any;
-    handleSubmit: (e: React.FormEvent) => Promise<void>;
-    isStatus204: boolean;
-}
-declare const useResetPassword: (apiUrl: string) => ResetPasswordHookReturn;
-
-interface FormData$1 {
-    new_password?: string;
-    re_new_password?: string;
-    uid?: string;
-    token?: string;
-}
-interface PasswordConfirmHookReturn {
-    loading: boolean;
-    formData: FormData$1;
-    error: any;
-    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
-    onSubmit: (e: React.FormEvent) => Promise<void>;
     status: any;
-    isStatus204: boolean;
 }
-declare const usePasswordConfirm: (initialFields: FormData$1, apiUrl: string) => PasswordConfirmHookReturn;
 
-interface FormData {
-    current_password?: string;
-    new_password?: string;
-    re_new_password?: string;
-}
-interface ChangePasswordHookReturn {
-    loading: boolean;
-    formData: FormData;
-    error: string | null;
-    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
-    onSubmit: (e: React.FormEvent) => Promise<void>;
-    status: any;
-}
-declare const useChangeAuthenticatedUserPassword: (initialFields: FormData, apiUrl: string) => ChangePasswordHookReturn;
-
-interface GoogleAuthHookReturn {
-    continueWithGoogle: () => Promise<void>;
-    authenticateWithGoogle: (state: string, code: string) => Promise<void>;
-    isAuthenticated: boolean | null;
-    error: any;
-    isStatus201: boolean;
-    loading: boolean;
-}
-declare const useGoogleAuth: (apiUrl: string) => GoogleAuthHookReturn;
-
-interface FacebookAuthHookReturn {
-    continueWithFacebook: () => Promise<void>;
-    authenticateWithFacebook: (state: string, code: string) => Promise<void>;
-    isAuthenticated: boolean | null;
-    error: any;
-    isStatus201: boolean;
-    loading: boolean;
-}
-declare const useFacebookAuth: (apiUrl: string) => FacebookAuthHookReturn;
-
-type AuthProviderProps = {
-    children: React$1.ReactNode;
-};
-declare const AuthProvider: React$1.FC<AuthProviderProps>;
+declare const store: _reduxjs_toolkit.EnhancedStore<{
+    auth: AuthState;
+}, any, _reduxjs_toolkit.Tuple<[redux.StoreEnhancer<{
+    dispatch: redux_thunk.ThunkDispatch<{
+        auth: AuthState;
+    }, undefined, redux.UnknownAction>;
+}>, redux.StoreEnhancer]>>;
 
-/**
- * A type representing a single error message string.
- */
-type ErrorMessage = string;
-/**
- * A type representing an array of error messages.
- */
-type ErrorMessageArray = string[];
-/**
- * A type representing an object where keys map to either a single error message
- * or an array of error messages.
- */
-type ErrorMessageObject = {
-    [key: string]: ErrorMessage | ErrorMessageArray;
+declare const auth: {
+    initialize: () => Promise<void>;
+    setAuthToken: (token: string) => void;
+    clearAuthToken: () => void;
 };
-/**
- * A union type for all possible error message inputs.
- */
-type ErrorMessageType = ErrorMessage | ErrorMessageArray | ErrorMessageObject;
-/**
- * Extracts and flattens various error message formats into a single array of strings.
- *
- * This function can handle:
- * - A single string: Returns an array with that string.
- * - An array of strings: Returns the array as is.
- * - An object: Iterates through the object's values and extracts all strings
- * and strings from arrays into a single flattened array.
- *
- * @param errorMsg The error message(s) to extract, which can be a string, array, or object.
- * @returns A flattened array of error message strings.
- */
-declare const extractErrorMessages: (errorMsg: ErrorMessageType) => string[];
 
-export { AuthProvider, extractErrorMessages, useActivate, useAuthicatedUser, useChangeAuthenticatedUserPassword, useFacebookAuth, useGoogleAuth, useLogin, useLogout, usePasswordConfirm, useResetPassword, useSignup };
+export { AuthProviderNative as AuthProvider, auth, store };