jamespot-front-business 1.0.3 → 1.1.3

package/dist/types.d.ts

@@ -1,43 +1,372 @@
-import * as jamespot_user_api from 'jamespot-user-api';
-import { Bookmark, SearchQuery, ApiWrapper, SearchQueryResult, ListFilterSpec, PagingResults, JamespotUserApi } from 'jamespot-user-api';
 import * as _reduxjs_toolkit from '@reduxjs/toolkit';
-import { Action } from '@reduxjs/toolkit';
+import { EntityState, Action, Dispatch as Dispatch$1, PayloadAction } from '@reduxjs/toolkit';
+import * as _reduxjs_toolkit_dist_tsHelpers from '@reduxjs/toolkit/dist/tsHelpers';
+import * as jamespot_user_api from 'jamespot-user-api';
+import { Application as Application$1, JamespotUserApi, ReservationList, BookableAssetList, AssetReservationConfiguration, Model as Model$1, JLandMap, JLicenseAvailable, jUserList } from 'jamespot-user-api';
+import * as redux from 'redux';
 import { Dispatch } from 'redux';
-import { ExtractDispatchExtensions } from '@reduxjs/toolkit/src/tsHelpers';
+import * as immer_dist_internal from 'immer/dist/internal';
+
+type ApplicationRootState = {
+    entities: {
+        applications: EntityState<Application$1>;
+    };
+};
+declare const Application: {
+    slice: _reduxjs_toolkit.Slice<EntityState<Application$1>, {
+        addOne: {
+            <S extends EntityState<Application$1>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S, EntityState<Application$1>, S>, entity: Application$1): S;
+            <S_1 extends EntityState<Application$1>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_1, EntityState<Application$1>, S_1>, action: {
+                payload: Application$1;
+                type: string;
+            }): S_1;
+        };
+        addMany: {
+            <S_2 extends EntityState<Application$1>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_2, EntityState<Application$1>, S_2>, entities: readonly Application$1[] | Record<_reduxjs_toolkit.EntityId, Application$1>): S_2;
+            <S_3 extends EntityState<Application$1>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_3, EntityState<Application$1>, S_3>, entities: {
+                payload: readonly Application$1[] | Record<_reduxjs_toolkit.EntityId, Application$1>;
+                type: string;
+            }): S_3;
+        };
+        setAll: {
+            <S_4 extends EntityState<Application$1>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_4, EntityState<Application$1>, S_4>, entities: readonly Application$1[] | Record<_reduxjs_toolkit.EntityId, Application$1>): S_4;
+            <S_5 extends EntityState<Application$1>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_5, EntityState<Application$1>, S_5>, entities: {
+                payload: readonly Application$1[] | Record<_reduxjs_toolkit.EntityId, Application$1>;
+                type: string;
+            }): S_5;
+        };
+    }, "applications">;
+    actions: {
+        addOne: _reduxjs_toolkit.ActionCreatorWithPayload<Application$1, "applications/addOne">;
+        addMany: _reduxjs_toolkit.ActionCreatorWithPayload<readonly Application$1[] | Record<_reduxjs_toolkit.EntityId, Application$1>, "applications/addMany">;
+        setAll: _reduxjs_toolkit.ActionCreatorWithPayload<readonly Application$1[] | Record<_reduxjs_toolkit.EntityId, Application$1>, "applications/setAll">;
+    };
+    selectors: _reduxjs_toolkit.EntitySelectors<Application$1, ApplicationRootState>;
+};
 
-interface BookmarkState {
-    entities: Array<Bookmark>;
+type RootState = Partial<AssetReservationRootState | ApplicationRootState | ModelRootState | ToastRootState>;
+type RootDispatch = Dispatch<Action>;
+type ThunkApiConfig<T> = {
+    dispatch: any;
+    state: RootState & T;
+    extra: {
+        jApi: JamespotUserApi;
+    };
+};
+
+type ReservationForm = {
+    date: string;
+    hourStart: string;
+    hourEnd: string;
+    uriUser?: string;
+    description?: string;
+};
+
+type Loading = {
     loading: 'idle' | 'pending';
+};
+
+type ReservationState = Loading & {
+    entities: ReservationList[];
     nbResults: number;
+    form: ReservationForm;
+};
+interface ReservationRootState {
+    reservation: ReservationState;
 }
-interface BookmarkRootState {
-    bookmark: BookmarkState;
+
+type BookableAssetState = Loading & {
+    entities: BookableAssetList[];
+    nbResults: number;
+};
+interface BookableAssetRootState {
+    bookableAsset: BookableAssetState;
 }
-declare const bookmarkSlice: _reduxjs_toolkit.Slice<BookmarkState, {}, "bookmark">;
-declare const fetchBookmarks: _reduxjs_toolkit.AsyncThunk<jamespot_user_api.ApiWrapper<jamespot_user_api.PagingResults<Bookmark>, string[]>, void, {}>;
-declare const selectBookmarkList: (state: BookmarkRootState) => Bookmark[];
-declare const selectBookmarkLoading: (state: BookmarkRootState) => "idle" | "pending";
 
-interface IJApi {
-    search: {
-        searchQuery: (query: SearchQuery, signal?: AbortSignal) => Promise<ApiWrapper<SearchQueryResult>>;
+type Configuration = AssetReservationConfiguration & Loading;
+interface ConfigurationRootState {
+    configuration: Configuration;
+}
+
+type AssetReservationRootState = {
+    assetReservation: BookableAssetRootState & ConfigurationRootState & ReservationRootState;
+};
+declare const AssetReservation: {
+    slice: {
+        name: "assetReservation";
+        reducer: redux.Reducer<redux.CombinedState<{
+            bookableAsset: BookableAssetState;
+            configuration: jamespot_user_api.AssetReservationConfiguration & Loading;
+            reservation: ReservationState;
+        }>, redux.AnyAction>;
     };
-    bookmark: {
-        getList: (filterSpecs: ListFilterSpec) => Promise<ApiWrapper<PagingResults<Bookmark>, string[]>>;
+    actions: {
+        fetchBookableAsset: _reduxjs_toolkit.AsyncThunk<jamespot_user_api.ApiPagingResults<jamespot_user_api.BookableAssetList, string[]>, void, {
+            dispatch: any;
+            state: RootState & BookableAssetRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchConfiguration: _reduxjs_toolkit.AsyncThunk<jamespot_user_api.ApiWrapper<jamespot_user_api.AssetReservationConfiguration, string[]>, void, {
+            dispatch: any;
+            state: RootState & jamespot_user_api.AssetReservationConfiguration & Loading;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchReservation: _reduxjs_toolkit.AsyncThunk<jamespot_user_api.ApiPagingResults<jamespot_user_api.ReservationList, jamespot_user_api.BaseMessages>, "history" | undefined, {
+            dispatch: any;
+            state: RootState & ReservationRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        setForm: _reduxjs_toolkit.ActionCreatorWithPayload<ReservationForm, "reservation/setForm">;
+        resetForm: _reduxjs_toolkit.ActionCreatorWithoutPayload<"reservation/resetForm">;
+        removeReservation: _reduxjs_toolkit.ActionCreatorWithPayload<number, "reservation/removeReservation">;
+    };
+    selectors: {
+        configuration: (state: AssetReservationRootState) => jamespot_user_api.AssetReservationConfiguration & Loading;
+        bookableAssetEntities: (state: AssetReservationRootState) => jamespot_user_api.BookableAssetList[];
+        bookableAssetLoading: (state: AssetReservationRootState) => "idle" | "pending";
+        reservationEntities: (state: AssetReservationRootState) => jamespot_user_api.ReservationList[];
+        reservationLoading: (state: AssetReservationRootState) => "idle" | "pending";
+        reservationForm: (state: AssetReservationRootState) => ReservationForm;
     };
-}
-declare type ExtraThunkType = {
-    jApi: IJApi;
 };
 
-declare type RootState = Partial<BookmarkRootState>;
-declare type RootDispatch = ExtractDispatchExtensions<unknown> & Dispatch<Action>;
-declare type ThunkApiConfig<T> = {
-    dispatch: RootDispatch;
-    state: RootState & T;
-    extra: {
-        jApi: JamespotUserApi;
+type ModelRootState = {
+    entities: {
+        models: EntityState<Model$1>;
+    };
+};
+declare const Model: {
+    slice: _reduxjs_toolkit.Slice<EntityState<Model$1<string>>, {
+        addOne: {
+            <S extends EntityState<Model$1<string>>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S, EntityState<Model$1<string>>, S>, entity: Model$1<string>): S;
+            <S_1 extends EntityState<Model$1<string>>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_1, EntityState<Model$1<string>>, S_1>, action: {
+                payload: Model$1<string>;
+                type: string;
+            }): S_1;
+        };
+        addMany: {
+            <S_2 extends EntityState<Model$1<string>>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_2, EntityState<Model$1<string>>, S_2>, entities: readonly Model$1<string>[] | Record<_reduxjs_toolkit.EntityId, Model$1<string>>): S_2;
+            <S_3 extends EntityState<Model$1<string>>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_3, EntityState<Model$1<string>>, S_3>, entities: {
+                payload: readonly Model$1<string>[] | Record<_reduxjs_toolkit.EntityId, Model$1<string>>;
+                type: string;
+            }): S_3;
+        };
+        setAll: {
+            <S_4 extends EntityState<Model$1<string>>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_4, EntityState<Model$1<string>>, S_4>, entities: readonly Model$1<string>[] | Record<_reduxjs_toolkit.EntityId, Model$1<string>>): S_4;
+            <S_5 extends EntityState<Model$1<string>>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_5, EntityState<Model$1<string>>, S_5>, entities: {
+                payload: readonly Model$1<string>[] | Record<_reduxjs_toolkit.EntityId, Model$1<string>>;
+                type: string;
+            }): S_5;
+        };
+    }, "models">;
+    actions: {
+        addOne: _reduxjs_toolkit.ActionCreatorWithPayload<Model$1<string>, "models/addOne">;
+        addMany: _reduxjs_toolkit.ActionCreatorWithPayload<readonly Model$1<string>[] | Record<_reduxjs_toolkit.EntityId, Model$1<string>>, "models/addMany">;
+        setAll: _reduxjs_toolkit.ActionCreatorWithPayload<readonly Model$1<string>[] | Record<_reduxjs_toolkit.EntityId, Model$1<string>>, "models/setAll">;
+    };
+    selectors: _reduxjs_toolkit.EntitySelectors<Model$1<string>, ModelRootState>;
+};
+
+type ToastType = 'success' | 'warning' | 'error';
+type ToastRootState = {
+    toasts: EntityState<ToastEntity>;
+};
+type ToastEntity = {
+    id: string;
+    label: string;
+    description?: string;
+    timeout: number;
+    type: ToastType;
+};
+declare const actions: {
+    addMessage: ({ id, ...toast }: Toast, type?: ToastType, timeout?: number) => (dispatch: Dispatch$1) => string;
+    success: (toast: Toast, timeout?: number) => (dispatch: Dispatch$1) => string;
+    warning: (toast: Toast, timeout?: number) => (dispatch: Dispatch$1) => string;
+    error: (toast: Toast, timeout?: number) => (dispatch: Dispatch$1) => string;
+};
+type Toast = {
+    id?: string;
+    label: string;
+    description?: string;
+};
+declare const Toast: {
+    slice: _reduxjs_toolkit.Slice<EntityState<ToastEntity>, {
+        addOne: {
+            <S extends EntityState<ToastEntity>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S, EntityState<ToastEntity>, S>, entity: ToastEntity): S;
+            <S_1 extends EntityState<ToastEntity>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_1, EntityState<ToastEntity>, S_1>, action: {
+                payload: ToastEntity;
+                type: string;
+            }): S_1;
+        };
+        removeOne: {
+            <S_2 extends EntityState<ToastEntity>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_2, EntityState<ToastEntity>, S_2>, key: _reduxjs_toolkit.EntityId): S_2;
+            <S_3 extends EntityState<ToastEntity>>(state: _reduxjs_toolkit_dist_tsHelpers.IsAny<S_3, EntityState<ToastEntity>, S_3>, key: {
+                payload: _reduxjs_toolkit.EntityId;
+                type: string;
+            }): S_3;
+        };
+    }, "toasts">;
+    actions: {
+        addOne: _reduxjs_toolkit.ActionCreatorWithPayload<ToastEntity, "toasts/addOne">;
+        removeOne: _reduxjs_toolkit.ActionCreatorWithPayload<_reduxjs_toolkit.EntityId, "toasts/removeOne">;
+        addMessage: ({ id, ...toast }: Toast, type?: ToastType, timeout?: number) => (dispatch: Dispatch$1) => string;
+        success: (toast: Toast, timeout?: number) => (dispatch: Dispatch$1) => string;
+        warning: (toast: Toast, timeout?: number) => (dispatch: Dispatch$1) => string;
+        error: (toast: Toast, timeout?: number) => (dispatch: Dispatch$1) => string;
+    };
+    selectors: _reduxjs_toolkit.EntitySelectors<ToastEntity, ToastRootState>;
+};
+
+type JLandMapFront = JLandMap & {
+    urlToJland?: string;
+};
+type JLandState = {
+    maps: Array<JLandMapFront>;
+    availableLicenses: JLicenseAvailable;
+    loading: 'idle' | 'pending';
+    loadingAvailableLicenses: 'idle' | 'pending';
+    loadingLicenseOperation: {
+        [key: number]: 'idle' | 'pending' | undefined;
+    };
+    loadingMapDeletion: 'idle' | 'pending';
+};
+type JLandRootState = {
+    jland: JLandState;
+};
+declare const jland: {
+    slice: _reduxjs_toolkit.Slice<{
+        maps: JLandMapFront[];
+        availableLicenses: JLicenseAvailable;
+        loading: "idle" | "pending";
+        loadingAvailableLicenses: "idle" | "pending";
+        loadingLicenseOperation: {
+            [key: number]: "idle" | "pending" | undefined;
+        };
+        loadingMapDeletion: "idle" | "pending";
+    }, {}, "jland">;
+    actions: {
+        assignLicense: _reduxjs_toolkit.AsyncThunk<boolean | undefined, {
+            map: JLandMapFront;
+            retrieveAllMaps: boolean;
+        }, {
+            dispatch: any;
+            state: RootState & JLandRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        unassignLicense: _reduxjs_toolkit.AsyncThunk<boolean | undefined, {
+            map: JLandMapFront;
+            retrieveAllMaps: boolean;
+        }, {
+            dispatch: any;
+            state: RootState & JLandRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        deleteJlandMap: _reduxjs_toolkit.AsyncThunk<boolean | undefined, {
+            map: JLandMapFront;
+            retrieveAllMaps: boolean;
+        }, {
+            dispatch: any;
+            state: RootState & JLandRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchJLandMaps: _reduxjs_toolkit.AsyncThunk<JLandMapFront[] | undefined, {
+            jlandUrlBase: string;
+            retrieveAllMaps: boolean;
+        }, {
+            dispatch: any;
+            state: RootState & JLandRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchJLandAvailableLicenses: _reduxjs_toolkit.AsyncThunk<JLicenseAvailable | undefined, void, {
+            dispatch: any;
+            state: RootState & JLandRootState;
+            extra: {
+                jApi: jamespot_user_api.JamespotUserApi;
+            };
+            rejectValue?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+    };
+    selectors: {
+        selectJLandMaps: (state: JLandRootState) => JLandMapFront[];
+        selectJLandAvailableLicenses: (state: JLandRootState) => JLicenseAvailable;
+    };
+    utils: {
+        buildUrlToJland: (map: JLandMap, hostname: string, urlBase: string) => string;
+    };
+};
+
+type UserCurrentRootState = {
+    userCurrent: jUserList;
+};
+declare const slice: _reduxjs_toolkit.Slice<jUserList, {
+    init: (_: immer_dist_internal.WritableDraft<jUserList>, { payload }: PayloadAction<jUserList>) => jUserList;
+}, "userCurrent">;
+declare const UserCurrent: {
+    slice: _reduxjs_toolkit.Slice<jUserList, {
+        init: (_: immer_dist_internal.WritableDraft<jUserList>, { payload }: PayloadAction<jUserList>) => jUserList;
+    }, "userCurrent">;
+    actions: {
+        init: _reduxjs_toolkit.ActionCreatorWithPayload<jUserList, "userCurrent/init">;
+    };
+    selectors: {
+        get: (state: UserCurrentRootState) => jUserList;
+    };
+    utils: {
+        isAdmin: (userCurrent: jUserList) => boolean;
     };
 };
 
-export { BookmarkRootState, BookmarkState, ExtraThunkType, IJApi, RootDispatch, RootState, ThunkApiConfig, bookmarkSlice, fetchBookmarks, selectBookmarkList, selectBookmarkLoading };
+export { Application, ApplicationRootState, AssetReservation, AssetReservationRootState, JLandMapFront, JLandRootState, JLandState, Model, ModelRootState, ReservationForm, RootDispatch, RootState, ThunkApiConfig, Toast, ToastRootState, UserCurrent, UserCurrentRootState, actions, jland, slice };

package/package.json

@@ -1,50 +1,51 @@
 {
-  "name": "jamespot-front-business",
-  "version": "1.0.3",
-  "description": "typescript utils",
-  "main": "dist/cjs.js",
-  "module": "dist/esm.js",
-  "types": "dist/types.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/Jamespot/jamespot-front-business.git"
-  },
-  "keywords": [
-    "typescript",
-    "jamespot",
-    "api",
-    "redux"
-  ],
-  "author": "Jamespot",
-  "devDependencies": {
-    "@changesets/cli": "^2.24.3",
-    "@rollup/plugin-commonjs": "^22.0.2",
-    "@rollup/plugin-typescript": "^8.3.3",
-    "@types/jest": "^28.1.4",
-    "@typescript-eslint/eslint-plugin": "^5.30.5",
-    "@typescript-eslint/parser": "^5.30.5",
-    "eslint": "^8.19.0",
-    "eslint-config-prettier": "^8.5.0",
-    "jest": "^28.1.2",
-    "jest-environment-jsdom": "^29.0.1",
-    "prettier": "^2.7.1",
-    "rollup": "^2.75.7",
-    "rollup-plugin-dts": "^4.2.2",
-    "ts-jest": "^28.0.5",
-    "tslib": "^2.4.0",
-    "typescript": "^4.7.4"
-  },
-  "dependencies": {
-    "@reduxjs/toolkit": "^1.8.5",
-    "react-redux": "^8.0.2",
-    "redux": "^4.2.0",
-    "jamespot-user-api": "../jamespot-user-api"
-  },
-  "scripts": {
-    "build": "rollup -c",
-    "watch": "rollup -c -w",
-    "format": "prettier --write --plugin-search-dir=. .",
-    "lint": "eslint --ignore-path .gitignore .",
-    "test": "jest"
-  }
-}
+    "name": "jamespot-front-business",
+    "version": "1.1.3",
+    "description": "typescript utils",
+    "main": "dist/cjs.js",
+    "module": "dist/esm.js",
+    "types": "dist/types.d.ts",
+    "scripts": {
+        "build": "rollup -c",
+        "watch": "rollup -c -w",
+        "format": "prettier --write --plugin-search-dir=. .",
+        "lint": "eslint --ignore-path .gitignore .",
+        "test": "jest",
+        "test:one": "jest --coverage=0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@github.com/Jamespot/jamespot-front-business.git"
+    },
+    "keywords": [
+        "typescript",
+        "jamespot",
+        "api",
+        "redux"
+    ],
+    "author": "Jamespot",
+    "devDependencies": {
+        "@changesets/cli": "^2.24.3",
+        "@rollup/plugin-commonjs": "^22.0.2",
+        "@rollup/plugin-typescript": "^8.3.3",
+        "@types/jest": "^28.1.4",
+        "@typescript-eslint/eslint-plugin": "^5.30.5",
+        "@typescript-eslint/parser": "^5.30.5",
+        "eslint": "^8.19.0",
+        "eslint-config-prettier": "^8.5.0",
+        "jest": "^28.1.2",
+        "jest-environment-jsdom": "^29.0.1",
+        "prettier": "^2.7.1",
+        "rollup": "^2.75.7",
+        "rollup-plugin-dts": "^4.2.2",
+        "ts-jest": "^28.0.5",
+        "tslib": "^2.4.0",
+        "typescript": "^4.7.4"
+    },
+    "dependencies": {
+        "@reduxjs/toolkit": "1.9.0",
+        "jamespot-user-api": "^1.0.89",
+        "react-redux": "7.2.9",
+        "redux": "4.2.0"
+    }
+}

package/tsconfig.json

@@ -15,17 +15,27 @@
         "sourceMap": true, // enables the use of source maps for debuggers and error reporting etc
         "sourceRoot": "/", // Specify the location where a debugger should locate TypeScript files instead of relative source locations.
 
+        
         // Strict Checks
-        "alwaysStrict": true, // Ensures that your files are parsed in the ECMAScript strict mode, and emit “use strict” for each source file.
+        "strict": true,
         "allowUnreachableCode": false, // pick up dead code paths
+        "allowUnusedLabels": false,
+        "alwaysStrict": true, // Ensures that your files are parsed in the ECMAScript strict mode, and emit “use strict” for each source file.
+        "exactOptionalPropertyTypes": true,
+        "noFallthroughCasesInSwitch": true,
         "noImplicitAny": true, // In some cases where no type annotations are present, TypeScript will fall back to a type of any for a variable when it cannot infer the type.
-        "strictNullChecks": true, // When strictNullChecks is true, null and undefined have their own distinct types and you’ll get a type error if you try to use them where a concrete value is expected.
-
-        // Linter Checks
+        "noImplicitOverride": false,
+        "noImplicitThis": true,
         "noImplicitReturns": true,
+        "noPropertyAccessFromIndexSignature": false,
         "noUncheckedIndexedAccess": true, // accessing index must always check for undefined
         "noUnusedLocals": true, // Report errors on unused local variables.
-        "noUnusedParameters": true // Report errors on unused parameters in functions
+        "noUnusedParameters": true, // Report errors on unused parameters in functions
+        "strictBindCallApply": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true, // When strictNullChecks is true, null and undefined have their own distinct types and you’ll get a type error if you try to use them where a concrete value is expected.
+        "strictPropertyInitialization": true,
+        "useUnknownInCatchVariables": true
     },
     "include": ["./**/*.ts"],
     "exclude": ["node_modules/**/*"]