@larisarozin/dodone-shared 1.0.0

package/README.md

@@ -0,0 +1,116 @@
+# dodone-shared Library
+
+A shared library for task management functionality with React hooks and authentication.
+
+## Installation
+
+```bash
+npm install dodone-shared
+```
+
+## Setup
+
+Wrap your application with both the `ConfigProvider` and `AuthProvider`:
+
+```tsx
+import React from 'react';
+import { ConfigProvider, AuthProvider } from 'dodone-shared';
+
+function App() {
+  return (
+    <ConfigProvider config={{ baseUrl: 'https://your-api-server.com' }}>
+      <AuthProvider>
+        {/* Your app components */}
+        <YourAppComponents />
+      </AuthProvider>
+    </ConfigProvider>
+  );
+}
+
+export default App;
+```
+
+## Usage
+
+### Authentication
+
+```tsx
+import { useAuth } from 'dodone-shared';
+
+function LoginComponent() {
+  const { user, token, authError, authLoading, dispatch } = useAuth();
+
+  const handleLogin = (user, token) => {
+    dispatch({ type: 'LOGIN_SUCCESS', user, token });
+  };
+
+  const handleLogout = () => {
+    dispatch({ type: 'LOGOUT' });
+  };
+
+  // ... rest of your component
+}
+```
+
+### Task Management Hooks
+
+All hooks now automatically use the configured base URL:
+
+```tsx
+import { 
+  useTaskItems, 
+  useTaskGroups, 
+  useTaskKinds, 
+  useTaskCategories,
+  useTeam 
+} from 'dodone-shared';
+
+function TaskDashboard() {
+  const userId = 123;
+  const groupId = 456;
+  const kindId = 789;
+
+  // No need to pass baseUrl anymore!
+  const { taskItems, loadingTaskItems, refreshTaskItems } = useTaskItems(userId);
+  const { taskGroups, taskGroupsLoading, refreshTaskGroups } = useTaskGroups(userId);
+  const { kinds, loading: kindsLoading } = useTaskKinds(groupId);
+  const { groups: categories, loading: categoriesLoading } = useTaskCategories(kindId);
+  const { team, loading: teamLoading } = useTeam();
+
+  // ... rest of your component
+}
+```
+
+## Configuration Options
+
+The `ConfigProvider` accepts a config object with the following options:
+
+- `baseUrl` (required): The base URL of your API server
+
+Future configuration options may include:
+- `timeout`: Request timeout in milliseconds
+- `defaultHeaders`: Default headers to include with all requests
+
+## Migration from Previous Versions
+
+If you were previously passing `baseUrl` as a parameter to hooks:
+
+**Before:**
+```tsx
+const { taskItems } = useTaskItems(userId, 'https://api.example.com');
+const { taskGroups } = useTaskGroups(userId, 'https://api.example.com');
+```
+
+**After:**
+```tsx
+// In your App.tsx or root component
+<ConfigProvider config={{ baseUrl: 'https://api.example.com' }}>
+  <AuthProvider>
+    {/* Your app */}
+  </AuthProvider>
+</ConfigProvider>
+
+// In your components
+const { taskItems } = useTaskItems(userId);
+const { taskGroups } = useTaskGroups(userId);
+```

package/dist/api/routes.d.ts

@@ -0,0 +1,66 @@
+export declare const API_ROUTES: {
+    auth: {
+        login: string;
+        register: string;
+        logout: string;
+        forgotPassword: string;
+        resetPassword: string;
+        sendPasswordResetEmail: string;
+    };
+    user: {
+        get: (id: number) => string;
+        create: string;
+        update: string;
+        delete: (id: number) => string;
+    };
+    notifications: {
+        register: string;
+        unregister: string;
+    };
+    grades: {
+        getList: () => string;
+    };
+    taskGroups: {
+        create: string;
+        update: string;
+        delete: (id: number) => string;
+        get: (id: number) => string;
+        getDetails: (id: number) => string;
+        getPagedList: () => string;
+        getPagedListDetails: () => string;
+    };
+    taskKinds: {
+        create: string;
+        update: string;
+        delete: (id: number) => string;
+        get: (id: number) => string;
+        getDetails: (id: number) => string;
+        getPagedList: () => string;
+        getPagedListDetails: () => string;
+    };
+    taskCategories: {
+        create: string;
+        update: string;
+        delete: (id: number) => string;
+        get: (id: number) => string;
+        getDetails: (id: number) => string;
+        getPagedList: () => string;
+        getPagedListDetails: () => string;
+    };
+    taskItems: {
+        create: string;
+        update: string;
+        copy: (id: number) => string;
+        archive: (id: number, archiving: boolean) => string;
+        archiveList: (archiving: boolean) => string;
+        pin: (id: number, pinning: boolean) => string;
+        pinList: (pinning: boolean) => string;
+        setActive: (id: number, activating: boolean) => string;
+        setActiveList: (activating: boolean) => string;
+        setComplete: (id: number, completing: boolean) => string;
+        setCompleteList: (completing: boolean) => string;
+        delete: (id: number) => string;
+        get: (id: number) => string;
+        getDetails: (id: number) => string;
+    };
+};

package/dist/api/routes.js

@@ -0,0 +1,87 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_ROUTES = void 0;
+exports.API_ROUTES = {
+    auth: {
+        login: "/api/auth/login",
+        register: "/api/auth/register",
+        logout: "/api/auth/logout",
+        forgotPassword: "/api/auth/forgot-password",
+        resetPassword: "/api/auth/reset-password",
+        sendPasswordResetEmail: "/api/auth/send-password-reset-email",
+    },
+    user: {
+        get: (id) => `/api/user/${id}`,
+        // getMe: "/api/user/me",
+        // getTeam: '/api/user/team/',
+        create: "/api/user",
+        update: "/api/user",
+        delete: (id) => `/api/user/${id}`,
+        // getPagedList: () => `/api/user/team-paged-list/`,
+    },
+    notifications: {
+        register: "/api/userdeviceregistration/register-device",
+        unregister: "/api/userdeviceregistration/unregister-device",
+    },
+    grades: {
+        getList: () => `/api/grade/list/`,
+    },
+    taskGroups: {
+        create: "/api/taskgroup",
+        update: "/api/taskgroup",
+        delete: (id) => `/api/taskgroup/${id}`,
+        get: (id) => `/api/taskgroup/${id}`,
+        getDetails: (id) => `/api/taskgroup/details/${id}`,
+        // getList: (userId: number) => `/api/taskgroup/list/${userId}`,
+        // getListDetails: (userId: number) => `/api/taskgroup/list-details/${userId}`,
+        getPagedList: () => `/api/taskgroup/paged-list/`,
+        getPagedListDetails: () => `/api/taskgroup/paged-list-details/`,
+    },
+    taskKinds: {
+        create: "/api/taskkind",
+        update: "/api/taskkind",
+        delete: (id) => `/api/taskkind/${id}`,
+        get: (id) => `/api/taskkind/${id}`,
+        getDetails: (id) => `/api/taskkind/details/${id}`,
+        // getList: (groupId: number) => `/api/taskkind/list/${groupId}`,
+        // getListDetails: (groupId: number) => `/api/taskkind/list-details/${groupId}`,
+        getPagedList: () => `/api/taskkind/paged-list/`,
+        getPagedListDetails: () => `/api/taskkind/paged-list-details/`,
+    },
+    taskCategories: {
+        create: "/api/taskcategory",
+        update: "/api/taskcategory",
+        delete: (id) => `/api/taskcategory/${id}`,
+        get: (id) => `/api/taskcategory/${id}`,
+        getDetails: (id) => `/api/taskcategory/details/${id}`,
+        // getList: (kindId: number) => `/api/taskcategory/list/${kindId}`,
+        // getListDetails: (kindId: number) => `/api/taskcategory/list-details/${kindId}`,
+        getPagedList: () => `/api/taskcategory/paged-list/`,
+        getPagedListDetails: () => `/api/taskcategory/paged-list-details/`,
+    },
+    taskItems: {
+        create: "/api/taskitem",
+        update: "/api/taskitem",
+        copy: (id) => `/api/taskitem/copy/${id}`,
+        archive: (id, archiving) => `/api/taskitem/${id}/${archiving}`,
+        archiveList: (archiving) => `/api/taskitem/archive-list/${archiving}`,
+        pin: (id, pinning) => `/api/taskitem/pin/${id}/${pinning}`,
+        pinList: (pinning) => `/api/taskitem/pin-list/${pinning}`,
+        setActive: (id, activating) => `/api/taskitem/set-active/${id}/${activating}`,
+        setActiveList: (activating) => `/api/taskitem/set-active-list/${activating}`,
+        setComplete: (id, completing) => `/api/taskitem/set-complete/${id}/${completing}`,
+        setCompleteList: (completing) => `/api/taskitem/set-complete-list/${completing}`,
+        delete: (id) => `/api/taskitem/${id}`,
+        get: (id) => `/api/taskitem/${id}`,
+        getDetails: (id) => `/api/taskitem/details/${id}`,
+        // getList: (userId: number) => `/api/taskitem/list/${userId}`,
+        // getListDetails: (userId: number) => `/api/taskitem/list-details/${userId}`,
+        // getPagedList: (request: PagedTaskItemListRequest) => `/api/taskitem/list/${request.parentId}`,
+        // getPagedListDetails: (request: PagedTaskItemListRequest) => `/api/taskitem/list-details/${request.parentId}`,
+    },
+};

package/dist/config/ConfigContext.d.ts

@@ -0,0 +1,4 @@
+export interface LibraryConfig {
+    baseUrl: string;
+}
+export declare const ConfigContext: import("react").Context<LibraryConfig | undefined>;

package/dist/config/ConfigContext.js

@@ -0,0 +1,10 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigContext = void 0;
+const react_1 = require("react");
+exports.ConfigContext = (0, react_1.createContext)(undefined);

package/dist/config/ConfigProvider.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+import { type LibraryConfig } from './ConfigContext';
+interface ConfigProviderProps {
+    children: ReactNode;
+    config: LibraryConfig;
+}
+export declare function ConfigProvider({ children, config }: ConfigProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/config/ConfigProvider.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigProvider = ConfigProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const ConfigContext_1 = require("./ConfigContext");
+function ConfigProvider({ children, config }) {
+    return ((0, jsx_runtime_1.jsx)(ConfigContext_1.ConfigContext.Provider, { value: config, children: children }));
+}

package/dist/config/useConfig.d.ts

@@ -0,0 +1 @@
+export declare function useConfig(): import("./ConfigContext").LibraryConfig;

package/dist/config/useConfig.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConfig = useConfig;
+const react_1 = require("react");
+const ConfigContext_1 = require("./ConfigContext");
+function useConfig() {
+    const context = (0, react_1.useContext)(ConfigContext_1.ConfigContext);
+    if (!context) {
+        throw new Error('useConfig must be used within a ConfigProvider. Make sure to wrap your app with <ConfigProvider config={{ baseUrl: "your-api-url" }}>');
+    }
+    return context;
+}

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    API_BASE_URL: string;
+};
+export default _default;

package/dist/config.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const API_BASE_URL = "http://192.168.1.126:5214";
+exports.default = {
+    API_BASE_URL,
+};

package/dist/hooks/auth/AuthContext.d.ts

@@ -0,0 +1,6 @@
+import { type AuthState, type AuthAction } from "./AuthState";
+type AuthContextType = AuthState & {
+    dispatch: React.Dispatch<AuthAction>;
+};
+export declare const AuthContext: import("react").Context<AuthContextType | undefined>;
+export {};

package/dist/hooks/auth/AuthContext.js

@@ -0,0 +1,10 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthContext = void 0;
+const react_1 = require("react");
+exports.AuthContext = (0, react_1.createContext)(undefined);

package/dist/hooks/auth/AuthProvider.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from 'react';
+interface AuthProviderProps {
+    children: ReactNode;
+}
+export declare function AuthProvider({ children }: AuthProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/hooks/auth/AuthProvider.js

@@ -0,0 +1,83 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthProvider = AuthProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+const react_1 = require("react");
+const AuthContext_1 = require("./AuthContext");
+const storage_1 = __importDefault(require("../../utils/storage"));
+const USER_KEY = 'auth_user';
+const TOKEN_KEY = 'auth_token';
+function authReducer(state, action) {
+    switch (action.type) {
+        case 'LOGIN_SUCCESS':
+            return Object.assign(Object.assign({}, state), { user: action.user, token: action.token, authError: '', authLoading: false });
+        case 'LOGOUT':
+            return Object.assign(Object.assign({}, state), { user: null, token: null, authError: '', authLoading: false });
+        case 'SET_ERROR':
+            return Object.assign(Object.assign({}, state), { authError: action.error, authLoading: false });
+        case 'SET_LOADING':
+            return Object.assign(Object.assign({}, state), { authLoading: action.loading });
+        default:
+            return state;
+    }
+}
+const initialState = {
+    user: null,
+    token: null,
+    authError: '',
+    authLoading: false,
+};
+function AuthProvider({ children }) {
+    const [state, dispatch] = (0, react_1.useReducer)(authReducer, initialState);
+    (0, react_1.useEffect)(() => {
+        (() => __awaiter(this, void 0, void 0, function* () {
+            const storedUser = yield storage_1.default.getItem(USER_KEY);
+            const storedToken = yield storage_1.default.getItem(TOKEN_KEY);
+            if (storedUser && storedToken) {
+                dispatch({
+                    type: 'LOGIN_SUCCESS',
+                    user: JSON.parse(storedUser),
+                    token: storedToken,
+                });
+            }
+        }))();
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (state.user) {
+            storage_1.default.setItem(USER_KEY, JSON.stringify(state.user));
+            // Store user_id separately for easy access (e.g., for celebration checks)
+            storage_1.default.setItem('user_id', state.user.id.toString());
+        }
+        else {
+            storage_1.default.removeItem(USER_KEY);
+            storage_1.default.removeItem('user_id');
+        }
+    }, [state.user]);
+    (0, react_1.useEffect)(() => {
+        if (state.token) {
+            storage_1.default.setItem(TOKEN_KEY, state.token);
+        }
+        else {
+            storage_1.default.removeItem(TOKEN_KEY);
+        }
+    }, [state.token]);
+    const value = (0, react_1.useMemo)(() => (Object.assign(Object.assign({}, state), { dispatch })), [state]);
+    return ((0, jsx_runtime_1.jsx)(AuthContext_1.AuthContext.Provider, { value: value, children: children }));
+}

package/dist/hooks/auth/AuthState.d.ts

@@ -0,0 +1,20 @@
+import { type User } from "../../types/User";
+export type AuthState = {
+    user: User | null;
+    token: string | null;
+    authError: string;
+    authLoading: boolean;
+};
+export type AuthAction = {
+    type: 'LOGIN_SUCCESS';
+    user: User;
+    token: string;
+} | {
+    type: 'LOGOUT';
+} | {
+    type: 'SET_ERROR';
+    error: string;
+} | {
+    type: 'SET_LOADING';
+    loading: boolean;
+};

package/dist/hooks/auth/AuthState.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hooks/auth/useAuth.d.ts

@@ -0,0 +1,3 @@
+export declare function useAuth(): import("./AuthState").AuthState & {
+    dispatch: React.Dispatch<import("./AuthState").AuthAction>;
+};

package/dist/hooks/auth/useAuth.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = useAuth;
+const react_1 = require("react");
+const AuthContext_1 = require("./AuthContext");
+function useAuth() {
+    const context = (0, react_1.useContext)(AuthContext_1.AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+    return context;
+}

package/dist/hooks/useAllowanceHistories.d.ts

@@ -0,0 +1,9 @@
+import { PagedListResponse } from "../utils/paging";
+import { AllowanceHistoryApprovalRequest, AllowanceHistoryClaimRequest, AllowanceHistoryResponse, PagedAllowanceHistoriesListRequest } from "../types/AllowanceHistory";
+export declare function useAllowanceHistories(request: PagedAllowanceHistoriesListRequest): {
+    pagedAllowanceHistories: PagedListResponse<AllowanceHistoryResponse> | undefined;
+    loadingAllowanceHistories: boolean;
+    refreshAllowanceHistories: (request: PagedAllowanceHistoriesListRequest) => void;
+    approveAllowance: (request: AllowanceHistoryApprovalRequest) => Promise<AllowanceHistoryResponse>;
+    claimAllowance: (request: AllowanceHistoryClaimRequest) => Promise<AllowanceHistoryResponse>;
+};

package/dist/hooks/useAllowanceHistories.js

@@ -0,0 +1,87 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+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.useAllowanceHistories = useAllowanceHistories;
+const react_1 = require("react");
+const useAuth_1 = require("./auth/useAuth");
+const useConfig_1 = require("../config/useConfig");
+const ApiClient_1 = require("../utils/ApiClient");
+function useAllowanceHistories(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [pagedAllowanceHistories, setPagedAllowanceHistories] = (0, react_1.useState)();
+    const [loadingAllowanceHistories, setLoadingAllowanceHistories] = (0, react_1.useState)(true);
+    const fetchAllowanceHistories = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoadingAllowanceHistories(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching allowance histories");
+            setLoadingAllowanceHistories(false);
+            return;
+        }
+        setLoadingAllowanceHistories(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.allowanceHistories.getPagedList(requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch allowance histories:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoadingAllowanceHistories(false);
+                return;
+            }
+            setPagedAllowanceHistories(data);
+        }
+        catch (err) {
+            console.error("Error fetching allowance histories:", err);
+        }
+        finally {
+            setLoadingAllowanceHistories(false);
+        }
+    }), [token, baseUrl]);
+    function refreshAllowanceHistories(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchAllowanceHistories to avoid state timing issues
+        fetchAllowanceHistories(request);
+    }
+    function approveAllowance(request) {
+        if (!baseUrl || !token) {
+            throw new Error("Missing baseUrl or token for API client");
+        }
+        const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+        const data = apiClient.allowanceHistories.approveAllowance(request);
+        //   refreshAllowanceHistories(pagedListRequest);
+        return data;
+    }
+    function claimAllowance(request) {
+        if (!baseUrl || !token) {
+            throw new Error("Missing baseUrl or token for API client");
+        }
+        const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+        const data = apiClient.allowanceHistories.claimAllowance(request);
+        //   refreshAllowanceHistories(pagedListRequest);
+        return data;
+    }
+    (0, react_1.useEffect)(() => {
+        // Only fetch on initial load if we have a valid request
+        if (pagedListRequest) {
+            fetchAllowanceHistories(pagedListRequest);
+        }
+    }, [fetchAllowanceHistories]);
+    return { pagedAllowanceHistories, loadingAllowanceHistories, refreshAllowanceHistories, approveAllowance, claimAllowance };
+}

package/dist/hooks/useAllowanceHistoryTaskItems.d.ts

@@ -0,0 +1,7 @@
+import { PagedListResponse } from "../utils/paging";
+import { AllowanceHistoryTaskItemResponse, PagedAllowanceHistoryTaskItemsListRequest } from "../types/AllowanceHistory";
+export declare function useAllowanceHistoryTaskItems(request: PagedAllowanceHistoryTaskItemsListRequest): {
+    pagedAllowanceHistoryTaskItems: PagedListResponse<AllowanceHistoryTaskItemResponse> | undefined;
+    loadingAllowanceHistoryTaskItems: boolean;
+    refreshAllowanceHistoryTaskItems: (request: PagedAllowanceHistoryTaskItemsListRequest) => void;
+};