rename rule set to rule

.gitignore

@@ -23,3 +23,5 @@ docker-compose.yml
 *.njsproj
 *.sln
 *.sw?
+
+generated/mammon/

docs/mammon-api.yml

@@ -0,0 +1,414 @@
+openapi: 3.1.0
+info:
+  title: OpenAPI definition
+  version: v0
+servers:
+- url: http://localhost:8080
+  description: Generated server url
+paths:
+  /ledgers/main/{ledgerId}:
+    put:
+      tags:
+      - ledger-controller
+      operationId: updateMainLedger
+      parameters:
+      - name: ledgerId
+        in: path
+        required: true
+        schema:
+          type: string
+          format: uuid
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateMainLedgerRequest"
+        required: true
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/MainLedgerResponse"
+  /ledgers/combined/{ledgerId}:
+    put:
+      tags:
+      - ledger-controller
+      operationId: updateCombinedLedger
+      parameters:
+      - name: ledgerId
+        in: path
+        required: true
+        schema:
+          type: string
+          format: uuid
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/UpdateCombinedLedgerRequest"
+        required: true
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CombinedLedgerResponse"
+  /process-activities:
+    post:
+      tags:
+      - processing-controller
+      operationId: processNewActivities
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+  /ledgers/main:
+    post:
+      tags:
+      - ledger-controller
+      operationId: createMainLedger
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateMainLedgerRequest"
+        required: true
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/MainLedgerResponse"
+  /ledgers/combined:
+    post:
+      tags:
+      - ledger-controller
+      operationId: createCombinedLedger
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateCombinedLedgerRequest"
+        required: true
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/CombinedLedgerResponse"
+  /characters/{characterId}/rule-book:
+    get:
+      tags:
+      - rule-book-controller
+      operationId: findByCharacterId
+      parameters:
+      - name: characterId
+        in: path
+        required: true
+        schema:
+          type: integer
+          format: int64
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/RuleBookResponse"
+    post:
+      tags:
+      - rule-book-controller
+      operationId: setCharacterRuleBook
+      parameters:
+      - name: characterId
+        in: path
+        required: true
+        schema:
+          type: integer
+          format: int64
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SetCharacterRuleBookRequest"
+        required: true
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                $ref: "#/components/schemas/RuleBookResponse"
+  /activity/fetch/{characterId}:
+    post:
+      tags:
+      - activity-controller
+      operationId: fetchNewActivitiesForCharacter
+      parameters:
+      - name: characterId
+        in: path
+        required: true
+        schema:
+          type: integer
+          format: int64
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+  /ledgers:
+    get:
+      tags:
+      - ledger-controller
+      operationId: findAll
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  oneOf:
+                  - $ref: "#/components/schemas/CombinedLedgerResponse"
+                  - $ref: "#/components/schemas/MainLedgerResponse"
+  /ledgers/{ledgerId}:
+    get:
+      tags:
+      - ledger-controller
+      operationId: findById
+      parameters:
+      - name: ledgerId
+        in: path
+        required: true
+        schema:
+          type: string
+          format: uuid
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                oneOf:
+                - $ref: "#/components/schemas/CombinedLedgerResponse"
+                - $ref: "#/components/schemas/MainLedgerResponse"
+  /characters:
+    get:
+      tags:
+      - character-controller
+      operationId: getCharacters
+      responses:
+        "404":
+          description: Not Found
+        "400":
+          description: Bad Request
+        "200":
+          description: OK
+          content:
+            '*/*':
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/CharacterResponse"
+components:
+  schemas:
+    UpdateMainLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+      required:
+      - name
+    MainLedgerResponse:
+      allOf:
+      - $ref: "#/components/schemas/LedgerResponse"
+      - type: object
+        properties:
+          ledgerId:
+            type: string
+            format: uuid
+          name:
+            type: string
+          balance:
+            type: number
+          type:
+            type: string
+            enum:
+            - MAIN
+      required:
+      - balance
+      - ledgerId
+      - name
+    UpdateCombinedLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+        memberLedgerIds:
+          type: array
+          items:
+            type: string
+            format: uuid
+      required:
+      - memberLedgerIds
+      - name
+    CombinedLedgerResponse:
+      allOf:
+      - $ref: "#/components/schemas/LedgerResponse"
+      - type: object
+        properties:
+          ledgerId:
+            type: string
+            format: uuid
+          name:
+            type: string
+          balance:
+            type: number
+          memberLedgerIds:
+            type: array
+            items:
+              type: string
+              format: uuid
+          type:
+            type: string
+            enum:
+            - COMBINED
+      required:
+      - balance
+      - ledgerId
+      - memberLedgerIds
+      - name
+    CreateMainLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+      required:
+      - name
+    CreateCombinedLedgerRequest:
+      type: object
+      properties:
+        name:
+          type: string
+        memberLedgerIds:
+          type: array
+          items:
+            type: string
+            format: uuid
+      required:
+      - memberLedgerIds
+      - name
+    RuleResponse:
+      type: object
+      properties:
+        rate:
+          type: string
+          enum:
+          - NONE
+          - VALUE
+          - JITA_BUY
+          - JITA_SELL
+          - EVE_ESTIMATE
+        fromLedgerId:
+          type: string
+          format: uuid
+        toLedgerId:
+          type: string
+          format: uuid
+      required:
+      - rate
+    RuleSetResponse:
+      type: object
+      properties:
+        rules:
+          type: array
+          items:
+            $ref: "#/components/schemas/RuleResponse"
+      required:
+      - rules
+    SetCharacterRuleBookRequest:
+      type: object
+      properties:
+        ruleSets:
+          type: object
+          additionalProperties:
+            $ref: "#/components/schemas/RuleSetResponse"
+      required:
+      - ruleSets
+    RuleBookResponse:
+      type: object
+      properties:
+        characterId:
+          type: integer
+          format: int64
+        ruleSets:
+          type: object
+          additionalProperties:
+            $ref: "#/components/schemas/RuleSetResponse"
+      required:
+      - characterId
+      - ruleSets
+    LedgerResponse:
+      type: object
+      discriminator:
+        propertyName: type
+      properties:
+        type:
+          type: string
+          enum:
+          - MAIN
+          - COMBINED
+    CharacterResponse:
+      type: object
+      properties:
+        characterId:
+          type: integer
+          format: int64
+        name:
+          type: string
+      required:
+      - characterId
+      - name

package.json

@@ -11,29 +11,28 @@
   },
   "dependencies": {
     "@heroicons/vue": "^2.0.18",
-    "@vueuse/components": "^10.5.0",
+    "@vueuse/components": "^14.3.0",
-    "@vueuse/core": "^10.2.1",
+    "@vueuse/core": "^14.3.0",
-    "@vueuse/integrations": "^10.2.1",
+    "@vueuse/integrations": "^14.3.0",
     "axios": "^1.4.0",
     "axios-rate-limit": "^1.3.1",
     "gemory": "file:",
     "loglevel": "^1.8.1",
     "loglevel-plugin-prefix": "^0.8.4",
-    "oidc-client-ts": "^3.0.1",
+    "pinia": "^3.0.4",
-    "pinia": "^2.1.6",
+    "sortablejs": "^1.15.7",
     "vue": "^3.3.4",
-    "vue-router": "^4.2.4"
+    "vue-router": "^5.0.7"
   },
   "devDependencies": {
-    "@types/node": "^20.4.5",
+    "@tailwindcss/vite": "^4.3.0",
-    "@vitejs/plugin-vue": "^5.0.4",
+    "@types/node": "^25.8.0",
-    "autoprefixer": "^10.4.14",
+    "@vitejs/plugin-vue": "^6.0.7",
-    "postcss": "^8.4.27",
+    "tailwindcss": "^4.3.0",
-    "tailwindcss": "^3.3.3",
+    "typescript": "^6.0.3",
-    "typescript": "^5.0.2",
+    "vite": "^8.0.13",
-    "vite": "^6.3.5",
+    "vite-plugin-runtime-env": "^1.0.0",
-    "vite-plugin-runtime-env": "^0.1.1",
+    "vitest": "^4.1.6",
-    "vitest": "^3.1.3",
+    "vue-tsc": "^3.2.9"
-    "vue-tsc": "^2.0.18"
   }
 }

postcss.config.js

@@ -1,8 +0,0 @@
-export default {
-  plugins: {
-    'postcss-import': {},
-    'tailwindcss/nesting': {},
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}

src/App.vue

@@ -1,14 +1,12 @@
 <script setup lang="ts">
-import { useAuthStore } from '@/auth';
 import { computed } from 'vue';
 import { RouterView, useRoute } from 'vue-router';
 import { Sidebar } from './sidebar';
 
 const route = useRoute();
-const authStore = useAuthStore();
 
 const hideSidebar = computed(() => {
-    return !authStore.isLoggedIn || route.name === 'callback' || route.name === 'about';
+    return route.name === 'callback' || route.name === 'about';
 });
 </script>
 
@@ -24,7 +22,9 @@ const hideSidebar = computed(() => {
     </template>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
+
 div.main-container {
     @apply px-4 sm:ml-64;
 }

src/auth.ts

@@ -1,49 +0,0 @@
-import log from "loglevel";
-import { Log, User, UserManager, WebStorageStateStore } from "oidc-client-ts";
-import { defineStore } from "pinia";
-import { computed, ref } from "vue";
-
-Log.setLogger(log);
-
-export const useAuthStore = defineStore('auth', () => {
-    const userManager = new UserManager({
-        authority: import.meta.env.VITE_AUTH_AUTHORITY,
-        client_id: import.meta.env.VITE_AUTH_CLIENT_ID,
-        client_secret: import.meta.env.VITE_AUTH_CLIENT_SECRET,
-        redirect_uri: import.meta.env.VITE_AUTH_REDIRECT_URI,
-        scope: import.meta.env.VITE_AUTH_SCOPE,
-        stateStore: new WebStorageStateStore({ store: window.localStorage }),
-        userStore: new WebStorageStateStore({ store: window.localStorage })
-    });
-
-    const user = ref<User>();
-    const isLoggedIn = computed(() => user.value?.expired === false);
-    const accessToken = computed(() => user.value?.access_token);
-    const username = computed(() => user.value?.profile.name ?? "");
-    const userId = computed(() => user.value?.profile.sub ?? "");
-
-    const redirect = async () => {
-        await userManager.signinRedirect();
-        log.info("Redirecting to login page");
-    }
-    const login = async () => {
-        await userManager.signinCallback();
-        log.debug("Logged in");
-    }
-    const logout = async () => {
-        await userManager.signoutRedirect();
-        log.debug("Logged out");
-    }
-
-    const setUser = (u?: User | null) => {
-        if (u) {
-            user.value = u;
-            log.debug("User loaded", u.profile.name);
-        } else {
-            user.value = undefined;
-        }
-    }
-    userManager.events.addUserLoaded(setUser);
-    userManager.getUser().then(setUser);
-    return { redirect, login, logout, isLoggedIn, accessToken, username, userId };
-});

src/characters/CharacterLabel.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+
+import {Character} from "./chartacters.ts";
+
+interface Props {
+  character: Character;
+  size?: number;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  size: 32
+})
+</script>
+
+<template>
+  <div class="flex">
+    <img class="me-2" :src="`https://images.evetech.net/characters/${character.characterId}/portrait?size=${size}`" />
+    <span>{{ character.name }}</span>
+  </div>
+</template>

src/characters/chartacters.ts

@@ -0,0 +1,28 @@
+import {activityControllerApi, characterControllerApi} from "@/mammon";
+import {defineStore} from "pinia";
+import {ref} from "vue";
+import {CharacterResponse} from "@/generated/mammon";
+
+export type Character = CharacterResponse
+
+export const useCharactersStore = defineStore('characters', () => {
+    const characters = ref<Character[]>([]);
+
+    const findById = async (characterId: number): Promise<Character | undefined> => {
+        let character = characters.value.find(c => c.characterId === characterId);
+
+        if (!character) {
+            await refresh(); // TODO call api instead of refresh
+            character = characters.value.find(c => c.characterId === characterId);
+        }
+        return character;
+    }
+
+    const reloadActivities = (characterId: number): Promise<void> => activityControllerApi.fetchNewActivitiesForCharacter(characterId) as Promise<void>;
+
+    const refresh = () => characterControllerApi.getCharacters().then(response => characters.value = response.data);
+
+    refresh();
+
+    return {characters, findById, reloadActivities, refresh};
+})

src/characters/index.ts

@@ -0,0 +1,3 @@
+export * from './chartacters.ts'
+
+export {default as CharacterLabel} from './CharacterLabel.vue';

src/components/Dropdown.vue

@@ -17,13 +17,21 @@ useEventListener('keyup', e => {
     <div class="dropdown" :class="{'dropdown-open': isOpen, 'dropdown-close': !isOpen}" v-on-click-outside="() => isOpen = false">
         <button @click="isOpen = !isOpen">
             <slot name="button" />
-            <Transition name="flip">
+            <Transition
+                enter-active-class="transition-transform"
+                enter-from-class="rotate-180"
+                leave-active-class="hidden"
+                leave-to-class="rotate-180">
                 <ChevronDownIcon v-if="!isOpen" class="chevron" />
                 <ChevronUpIcon v-else class="chevron" />
             </Transition>
         </button>
 
-        <Transition name="fade">
+        <Transition
+            enter-active-class="transition-opacity"
+            enter-from-class="opacity-0"
+            leave-from-class="transition-opacity"
+            leave-to-class="opacity-0">
             <div v-if="isOpen" class="relative">
                 <div class="z-10 divide-y rounded-b-md absolute">
                     <slot />
@@ -33,27 +41,10 @@ useEventListener('keyup', e => {
     </div>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
+
 .chevron {
     @apply w-4 h-4 ms-1;
 }
-
-.fade-enter-from, .fade-leave-to {
-  opacity: 0;
-}
-
-.fade-enter-active, .fade-leave-active {
-    @apply transition-opacity;
-}
-
-.flip-enter-from, .flip-leave-to {
-  transform: rotate(180deg);
-}
-
-.flip-enter-active {
-  @apply transition-transform;
-}
-.flip-leave-active {
-   display: none; 
-}
 </style>

src/components/Modal.vue

@@ -34,7 +34,8 @@ useEventListener('keyup', e => {
     </Transition>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 .fade-enter-from, .fade-leave-to {
     @apply opacity-0;
 }

src/components/SelectInput.vue

@@ -0,0 +1,71 @@
+<script setup lang="ts" generic="T">
+import {vOnClickOutside} from '@vueuse/components';
+import {useVirtualList} from '@vueuse/core';
+import {computed, ref} from 'vue';
+
+interface Props {
+  items: T[];
+  itemHeight?: number;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    itemHeight: 24,
+});
+
+const modelValue = defineModel<T>();
+
+const isOpen = ref(false);
+const currentIndex = ref(-1);
+const {list, scrollTo, containerProps, wrapperProps} = useVirtualList(computed(() => props.items), {
+    itemHeight: () => props.itemHeight,
+    overscan: 3,
+});
+
+const moveDown = () => {
+    currentIndex.value = currentIndex.value >= props.items.length - 1 ? 0 : currentIndex.value + 1;
+    scrollTo(currentIndex.value);
+};
+const moveUp = () => {
+    currentIndex.value = currentIndex.value <= 0 ? props.items.length - 1 : currentIndex.value - 1;
+    scrollTo(currentIndex.value);
+};
+const select = (item?: T) => {
+    modelValue.value = item;
+    currentIndex.value = -1;
+    isOpen.value = false;
+};
+const submit = () => {
+    if (currentIndex.value >= 0 && currentIndex.value < props.items.length) {
+        select(props.items[currentIndex.value]);
+    } else if (modelValue.value === undefined && props.items.length > 0) {
+        select(props.items[0]);
+    }
+};
+</script>
+
+<template>
+    <div @click="isOpen = true" v-on-click-outside="() => isOpen = false">
+      <div class="fake-input" @keyup.enter="submit" @keyup.down="moveDown" @keyup.up="moveUp">
+        <slot name="input" :value="modelValue" />
+      </div>
+        <div v-if="isOpen && items.length" class="z-20 absolute">
+            <div v-bind="containerProps" class="rounded-b" style="height: 300px">
+                <div v-bind="wrapperProps">
+                    <div v-for="s in list" :key="s.index"
+                        class="hover:bg-slate-700 cursor-pointer"
+                        :class="s.index === currentIndex ? 'bg-emerald-500' : 'bg-slate-500'"
+                        @click.stop="select(s.data)">
+                        <slot name="item" :item="s.data" />
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+@reference "tailwindcss";
+.fake-input {
+    @apply flex border bg-slate-500 rounded px-1 py-0.5;
+}
+</style>

src/components/SliderCheckbox.vue

@@ -10,7 +10,8 @@ const modelValue = defineModel({ default: false });
     </label>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
     input:checked ~ span:last-child {
         --tw-translate-x: 1.25rem;
     }

src/components/index.ts

@@ -3,6 +3,7 @@ export { default as Dropdown } from './Dropdown.vue';
 export { default as LoadingSpinner } from './LoadingSpinner.vue';
 export { default as Modal } from './Modal.vue';
 export { default as ProgressBar } from './ProgressBar.vue';
+export { default as SelectInput } from './SelectInput.vue';
 export { default as SliderCheckbox } from './SliderCheckbox.vue';
 export { default as Tooltip } from './tooltip/Tooltip.vue';
 

src/components/table/SortableHeader.vue

@@ -32,7 +32,8 @@ const emit = defineEmits<Emit>();
     </component>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 .sort-header {
     @apply relative h-8 pe-3;
 }

src/components/table/VirtualScrollTable.vue

@@ -67,7 +67,8 @@ const itemHeightStyle = computed(() => {
     <slot v-else name="empty" />
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 div.table-container {
     @apply bg-slate-600;
     max-height: calc(100vh - v-bind(ypx));

src/formaters.ts

@@ -11,7 +11,6 @@ export const percentFormater = new Intl.NumberFormat("en-US", {
     maximumFractionDigits: 0
 });
 
-
 const timeFormat = new Intl.NumberFormat("en-US", {
     minimumFractionDigits: 0,
     maximumFractionDigits: 0,

src/generated/mammon/api.ts

@@ -0,0 +1,985 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import type { Configuration } from './configuration';
+import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
+import globalAxios from 'axios';
+// Some imports not used depending on template conditions
+// @ts-ignore
+import { DUMMY_BASE_URL, assertParamExists, setApiKeyToObject, setBasicAuthToObject, setBearerAuthToObject, setOAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction, replaceWithSerializableTypeIfNeeded } from './common';
+import type { RequestArgs } from './base';
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS, BaseAPI, RequiredError, operationServerMap } from './base';
+
+export interface CharacterResponse {
+    'characterId': number;
+    'name': string;
+}
+export interface CombinedLedgerResponse extends LedgerResponse {
+    'ledgerId': string;
+    'name': string;
+    'balance': number;
+    'memberLedgerIds': Array<string>;
+    'type'?: CombinedLedgerResponseTypeEnum;
+}
+
+export const CombinedLedgerResponseTypeEnum = {
+    Combined: 'COMBINED',
+} as const;
+
+export type CombinedLedgerResponseTypeEnum = typeof CombinedLedgerResponseTypeEnum[keyof typeof CombinedLedgerResponseTypeEnum];
+
+export interface CreateCombinedLedgerRequest {
+    'name': string;
+    'memberLedgerIds': Array<string>;
+}
+export interface CreateMainLedgerRequest {
+    'name': string;
+}
+/**
+ * @type FindAll200ResponseInner
+ */
+export type FindAll200ResponseInner = CombinedLedgerResponse | MainLedgerResponse;
+
+export interface LedgerResponse {
+    'type'?: LedgerResponseTypeEnum;
+}
+
+export const LedgerResponseTypeEnum = {
+    Main: 'MAIN',
+    Combined: 'COMBINED',
+} as const;
+
+export type LedgerResponseTypeEnum = typeof LedgerResponseTypeEnum[keyof typeof LedgerResponseTypeEnum];
+
+export interface MainLedgerResponse extends LedgerResponse {
+    'ledgerId': string;
+    'name': string;
+    'balance': number;
+    'type'?: MainLedgerResponseTypeEnum;
+}
+
+export const MainLedgerResponseTypeEnum = {
+    Main: 'MAIN',
+} as const;
+
+export type MainLedgerResponseTypeEnum = typeof MainLedgerResponseTypeEnum[keyof typeof MainLedgerResponseTypeEnum];
+
+export interface RuleBookResponse {
+    'characterId': number;
+    'rules': { [key: string]: RuleResponse; };
+}
+export interface RuleClauseResponse {
+    'rate': RuleClauseResponseRateEnum;
+    'fromLedgerId'?: string;
+    'toLedgerId'?: string;
+}
+
+export const RuleClauseResponseRateEnum = {
+    None: 'NONE',
+    Value: 'VALUE',
+    JitaBuy: 'JITA_BUY',
+    JitaSell: 'JITA_SELL',
+    EveEstimate: 'EVE_ESTIMATE',
+} as const;
+
+export type RuleClauseResponseRateEnum = typeof RuleClauseResponseRateEnum[keyof typeof RuleClauseResponseRateEnum];
+
+export interface RuleResponse {
+    'rules': Array<RuleClauseResponse>;
+}
+export interface SetCharacterRuleBookRequest {
+    'rules': { [key: string]: RuleResponse; };
+}
+export interface UpdateCombinedLedgerRequest {
+    'name': string;
+    'memberLedgerIds': Array<string>;
+}
+export interface UpdateMainLedgerRequest {
+    'name': string;
+}
+
+/**
+ * ActivityControllerApi - axios parameter creator
+ */
+export const ActivityControllerApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fetchNewActivitiesForCharacter: async (characterId: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'characterId' is not null or undefined
+            assertParamExists('fetchNewActivitiesForCharacter', 'characterId', characterId)
+            const localVarPath = `/activity/fetch/{characterId}`
+                .replace('{characterId}', encodeURIComponent(String(characterId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * ActivityControllerApi - functional programming interface
+ */
+export const ActivityControllerApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = ActivityControllerApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fetchNewActivitiesForCharacter(characterId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fetchNewActivitiesForCharacter(characterId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ActivityControllerApi.fetchNewActivitiesForCharacter']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * ActivityControllerApi - factory interface
+ */
+export const ActivityControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = ActivityControllerApiFp(configuration)
+    return {
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fetchNewActivitiesForCharacter(characterId: number, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.fetchNewActivitiesForCharacter(characterId, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * ActivityControllerApi - object-oriented interface
+ */
+export class ActivityControllerApi extends BaseAPI {
+    /**
+     * 
+     * @param {number} characterId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public fetchNewActivitiesForCharacter(characterId: number, options?: RawAxiosRequestConfig) {
+        return ActivityControllerApiFp(this.configuration).fetchNewActivitiesForCharacter(characterId, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * CharacterControllerApi - axios parameter creator
+ */
+export const CharacterControllerApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getCharacters: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/characters`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * CharacterControllerApi - functional programming interface
+ */
+export const CharacterControllerApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = CharacterControllerApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getCharacters(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<CharacterResponse>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getCharacters(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['CharacterControllerApi.getCharacters']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * CharacterControllerApi - factory interface
+ */
+export const CharacterControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = CharacterControllerApiFp(configuration)
+    return {
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getCharacters(options?: RawAxiosRequestConfig): AxiosPromise<Array<CharacterResponse>> {
+            return localVarFp.getCharacters(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * CharacterControllerApi - object-oriented interface
+ */
+export class CharacterControllerApi extends BaseAPI {
+    /**
+     * 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public getCharacters(options?: RawAxiosRequestConfig) {
+        return CharacterControllerApiFp(this.configuration).getCharacters(options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * LedgerControllerApi - axios parameter creator
+ */
+export const LedgerControllerApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * 
+         * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        createCombinedLedger: async (createCombinedLedgerRequest: CreateCombinedLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'createCombinedLedgerRequest' is not null or undefined
+            assertParamExists('createCombinedLedger', 'createCombinedLedgerRequest', createCombinedLedgerRequest)
+            const localVarPath = `/ledgers/combined`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(createCombinedLedgerRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {CreateMainLedgerRequest} createMainLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        createMainLedger: async (createMainLedgerRequest: CreateMainLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'createMainLedgerRequest' is not null or undefined
+            assertParamExists('createMainLedger', 'createMainLedgerRequest', createMainLedgerRequest)
+            const localVarPath = `/ledgers/main`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(createMainLedgerRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        findAll: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/ledgers`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        findById: async (ledgerId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'ledgerId' is not null or undefined
+            assertParamExists('findById', 'ledgerId', ledgerId)
+            const localVarPath = `/ledgers/{ledgerId}`
+                .replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        updateCombinedLedger: async (ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'ledgerId' is not null or undefined
+            assertParamExists('updateCombinedLedger', 'ledgerId', ledgerId)
+            // verify required parameter 'updateCombinedLedgerRequest' is not null or undefined
+            assertParamExists('updateCombinedLedger', 'updateCombinedLedgerRequest', updateCombinedLedgerRequest)
+            const localVarPath = `/ledgers/combined/{ledgerId}`
+                .replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(updateCombinedLedgerRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        updateMainLedger: async (ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'ledgerId' is not null or undefined
+            assertParamExists('updateMainLedger', 'ledgerId', ledgerId)
+            // verify required parameter 'updateMainLedgerRequest' is not null or undefined
+            assertParamExists('updateMainLedger', 'updateMainLedgerRequest', updateMainLedgerRequest)
+            const localVarPath = `/ledgers/main/{ledgerId}`
+                .replace('{ledgerId}', encodeURIComponent(String(ledgerId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(updateMainLedgerRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * LedgerControllerApi - functional programming interface
+ */
+export const LedgerControllerApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = LedgerControllerApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * 
+         * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CombinedLedgerResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.createCombinedLedger(createCombinedLedgerRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.createCombinedLedger']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {CreateMainLedgerRequest} createMainLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MainLedgerResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.createMainLedger(createMainLedgerRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.createMainLedger']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async findAll(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<FindAll200ResponseInner>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.findAll(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.findAll']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async findById(ledgerId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FindAll200ResponseInner>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.findById(ledgerId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.findById']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CombinedLedgerResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.updateCombinedLedger']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MainLedgerResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.updateMainLedger(ledgerId, updateMainLedgerRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['LedgerControllerApi.updateMainLedger']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * LedgerControllerApi - factory interface
+ */
+export const LedgerControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = LedgerControllerApiFp(configuration)
+    return {
+        /**
+         * 
+         * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<CombinedLedgerResponse> {
+            return localVarFp.createCombinedLedger(createCombinedLedgerRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * 
+         * @param {CreateMainLedgerRequest} createMainLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<MainLedgerResponse> {
+            return localVarFp.createMainLedger(createMainLedgerRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        findAll(options?: RawAxiosRequestConfig): AxiosPromise<Array<FindAll200ResponseInner>> {
+            return localVarFp.findAll(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        findById(ledgerId: string, options?: RawAxiosRequestConfig): AxiosPromise<FindAll200ResponseInner> {
+            return localVarFp.findById(ledgerId, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<CombinedLedgerResponse> {
+            return localVarFp.updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * 
+         * @param {string} ledgerId 
+         * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig): AxiosPromise<MainLedgerResponse> {
+            return localVarFp.updateMainLedger(ledgerId, updateMainLedgerRequest, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * LedgerControllerApi - object-oriented interface
+ */
+export class LedgerControllerApi extends BaseAPI {
+    /**
+     * 
+     * @param {CreateCombinedLedgerRequest} createCombinedLedgerRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public createCombinedLedger(createCombinedLedgerRequest: CreateCombinedLedgerRequest, options?: RawAxiosRequestConfig) {
+        return LedgerControllerApiFp(this.configuration).createCombinedLedger(createCombinedLedgerRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * 
+     * @param {CreateMainLedgerRequest} createMainLedgerRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public createMainLedger(createMainLedgerRequest: CreateMainLedgerRequest, options?: RawAxiosRequestConfig) {
+        return LedgerControllerApiFp(this.configuration).createMainLedger(createMainLedgerRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public findAll(options?: RawAxiosRequestConfig) {
+        return LedgerControllerApiFp(this.configuration).findAll(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * 
+     * @param {string} ledgerId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public findById(ledgerId: string, options?: RawAxiosRequestConfig) {
+        return LedgerControllerApiFp(this.configuration).findById(ledgerId, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * 
+     * @param {string} ledgerId 
+     * @param {UpdateCombinedLedgerRequest} updateCombinedLedgerRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public updateCombinedLedger(ledgerId: string, updateCombinedLedgerRequest: UpdateCombinedLedgerRequest, options?: RawAxiosRequestConfig) {
+        return LedgerControllerApiFp(this.configuration).updateCombinedLedger(ledgerId, updateCombinedLedgerRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * 
+     * @param {string} ledgerId 
+     * @param {UpdateMainLedgerRequest} updateMainLedgerRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public updateMainLedger(ledgerId: string, updateMainLedgerRequest: UpdateMainLedgerRequest, options?: RawAxiosRequestConfig) {
+        return LedgerControllerApiFp(this.configuration).updateMainLedger(ledgerId, updateMainLedgerRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * ProcessingControllerApi - axios parameter creator
+ */
+export const ProcessingControllerApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        processNewActivities: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/process-activities`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * ProcessingControllerApi - functional programming interface
+ */
+export const ProcessingControllerApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = ProcessingControllerApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async processNewActivities(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.processNewActivities(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ProcessingControllerApi.processNewActivities']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * ProcessingControllerApi - factory interface
+ */
+export const ProcessingControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = ProcessingControllerApiFp(configuration)
+    return {
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        processNewActivities(options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.processNewActivities(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * ProcessingControllerApi - object-oriented interface
+ */
+export class ProcessingControllerApi extends BaseAPI {
+    /**
+     * 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public processNewActivities(options?: RawAxiosRequestConfig) {
+        return ProcessingControllerApiFp(this.configuration).processNewActivities(options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * RuleBookControllerApi - axios parameter creator
+ */
+export const RuleBookControllerApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        findByCharacterId: async (characterId: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'characterId' is not null or undefined
+            assertParamExists('findByCharacterId', 'characterId', characterId)
+            const localVarPath = `/characters/{characterId}/rule-book`
+                .replace('{characterId}', encodeURIComponent(String(characterId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {SetCharacterRuleBookRequest} setCharacterRuleBookRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setCharacterRuleBook: async (characterId: number, setCharacterRuleBookRequest: SetCharacterRuleBookRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'characterId' is not null or undefined
+            assertParamExists('setCharacterRuleBook', 'characterId', characterId)
+            // verify required parameter 'setCharacterRuleBookRequest' is not null or undefined
+            assertParamExists('setCharacterRuleBook', 'setCharacterRuleBookRequest', setCharacterRuleBookRequest)
+            const localVarPath = `/characters/{characterId}/rule-book`
+                .replace('{characterId}', encodeURIComponent(String(characterId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = '*/*';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(setCharacterRuleBookRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * RuleBookControllerApi - functional programming interface
+ */
+export const RuleBookControllerApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = RuleBookControllerApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async findByCharacterId(characterId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.findByCharacterId(characterId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['RuleBookControllerApi.findByCharacterId']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {SetCharacterRuleBookRequest} setCharacterRuleBookRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async setCharacterRuleBook(characterId: number, setCharacterRuleBookRequest: SetCharacterRuleBookRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RuleBookResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.setCharacterRuleBook(characterId, setCharacterRuleBookRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['RuleBookControllerApi.setCharacterRuleBook']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * RuleBookControllerApi - factory interface
+ */
+export const RuleBookControllerApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = RuleBookControllerApiFp(configuration)
+    return {
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        findByCharacterId(characterId: number, options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
+            return localVarFp.findByCharacterId(characterId, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * 
+         * @param {number} characterId 
+         * @param {SetCharacterRuleBookRequest} setCharacterRuleBookRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        setCharacterRuleBook(characterId: number, setCharacterRuleBookRequest: SetCharacterRuleBookRequest, options?: RawAxiosRequestConfig): AxiosPromise<RuleBookResponse> {
+            return localVarFp.setCharacterRuleBook(characterId, setCharacterRuleBookRequest, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * RuleBookControllerApi - object-oriented interface
+ */
+export class RuleBookControllerApi extends BaseAPI {
+    /**
+     * 
+     * @param {number} characterId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public findByCharacterId(characterId: number, options?: RawAxiosRequestConfig) {
+        return RuleBookControllerApiFp(this.configuration).findByCharacterId(characterId, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * 
+     * @param {number} characterId 
+     * @param {SetCharacterRuleBookRequest} setCharacterRuleBookRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public setCharacterRuleBook(characterId: number, setCharacterRuleBookRequest: SetCharacterRuleBookRequest, options?: RawAxiosRequestConfig) {
+        return RuleBookControllerApiFp(this.configuration).setCharacterRuleBook(characterId, setCharacterRuleBookRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+

src/generated/mammon/base.ts

@@ -0,0 +1,62 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import type { Configuration } from './configuration';
+// Some imports not used depending on template conditions
+// @ts-ignore
+import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
+import globalAxios from 'axios';
+
+export const BASE_PATH = "http://localhost:8080".replace(/\/+$/, "");
+
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+export interface RequestArgs {
+    url: string;
+    options: RawAxiosRequestConfig;
+}
+
+export class BaseAPI {
+    protected configuration: Configuration | undefined;
+
+    constructor(configuration?: Configuration, protected basePath: string = BASE_PATH, protected axios: AxiosInstance = globalAxios) {
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = configuration.basePath ?? basePath;
+        }
+    }
+};
+
+export class RequiredError extends Error {
+    constructor(public field: string, msg?: string) {
+        super(msg);
+        this.name = "RequiredError"
+    }
+}
+
+interface ServerMap {
+    [key: string]: {
+        url: string,
+        description: string,
+    }[];
+}
+
+export const operationServerMap: ServerMap = {
+}

src/generated/mammon/common.ts

@@ -0,0 +1,127 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import type { Configuration } from "./configuration";
+import type { RequestArgs } from "./base";
+import type { AxiosInstance, AxiosResponse } from 'axios';
+import { RequiredError } from "./base";
+
+export const DUMMY_BASE_URL = 'https://example.com'
+
+/**
+ *
+ * @throws {RequiredError}
+ */
+export const assertParamExists = function (functionName: string, paramName: string, paramValue: unknown) {
+    if (paramValue === null || paramValue === undefined) {
+        throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
+    }
+}
+
+export const setApiKeyToObject = async function (object: any, keyParamName: string, configuration?: Configuration) {
+    if (configuration && configuration.apiKey) {
+        const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+            ? await configuration.apiKey(keyParamName)
+            : await configuration.apiKey;
+        object[keyParamName] = localVarApiKeyValue;
+    }
+}
+
+export const setBasicAuthToObject = function (object: any, configuration?: Configuration) {
+    if (configuration && (configuration.username || configuration.password)) {
+        object["auth"] = { username: configuration.username, password: configuration.password };
+    }
+}
+
+export const setBearerAuthToObject = async function (object: any, configuration?: Configuration) {
+    if (configuration && configuration.accessToken) {
+        const accessToken = typeof configuration.accessToken === 'function'
+            ? await configuration.accessToken()
+            : await configuration.accessToken;
+        object["Authorization"] = "Bearer " + accessToken;
+    }
+}
+
+export const setOAuthToObject = async function (object: any, name: string, scopes: string[], configuration?: Configuration) {
+    if (configuration && configuration.accessToken) {
+        const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
+            ? await configuration.accessToken(name, scopes)
+            : await configuration.accessToken;
+        object["Authorization"] = "Bearer " + localVarAccessTokenValue;
+    }
+}
+
+
+function setFlattenedQueryParams(urlSearchParams: URLSearchParams, parameter: any, key: string = ""): void {
+    if (parameter == null) return;
+    if (typeof parameter === "object") {
+        if (Array.isArray(parameter) || parameter instanceof Set) {
+            (parameter as any[]).forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
+        }
+        else {
+            Object.keys(parameter).forEach(currentKey =>
+                setFlattenedQueryParams(urlSearchParams, parameter[currentKey], `${key}${key !== '' ? '.' : ''}${currentKey}`)
+            );
+        }
+    }
+    else {
+        if (urlSearchParams.has(key)) {
+            urlSearchParams.append(key, parameter);
+        }
+        else {
+            urlSearchParams.set(key, parameter);
+        }
+    }
+}
+
+export const setSearchParams = function (url: URL, ...objects: any[]) {
+    const searchParams = new URLSearchParams(url.search);
+    setFlattenedQueryParams(searchParams, objects);
+    url.search = searchParams.toString();
+}
+
+/**
+ * JSON serialization helper function which replaces instances of unserializable types with serializable ones.
+ * This function will run for every key-value pair encountered by JSON.stringify while traversing an object.
+ * Converting a set to a string will return an empty object, so an intermediate conversion to an array is required.
+ */
+// @ts-ignore
+export const replaceWithSerializableTypeIfNeeded = function(key: string, value: any) {
+    if (value instanceof Set) {
+        return Array.from(value);
+    } else {
+        return value;
+    }
+}
+
+export const serializeDataIfNeeded = function (value: any, requestOptions: any, configuration?: Configuration) {
+    const nonString = typeof value !== 'string';
+    const needsSerialization = nonString && configuration && configuration.isJsonMime
+        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
+        : nonString;
+    return needsSerialization
+        ? JSON.stringify(value !== undefined ? value : {}, replaceWithSerializableTypeIfNeeded)
+        : (value || "");
+}
+
+export const toPathString = function (url: URL) {
+    return url.pathname + url.search + url.hash
+}
+
+export const createRequestFunction = function (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) {
+    return <T = unknown, R = AxiosResponse<T>>(axios: AxiosInstance = globalAxios, basePath: string = BASE_PATH) => {
+        const axiosRequestArgs = {...axiosArgs.options, url: (axios.defaults.baseURL ? '' : configuration?.basePath ?? basePath) + axiosArgs.url};
+        return axios.request<T, R>(axiosRequestArgs);
+    };
+}

src/generated/mammon/configuration.ts

@@ -0,0 +1,121 @@
+/* tslint:disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+interface AWSv4Configuration {
+  options?: {
+    region?: string
+    service?: string
+  }
+  credentials?: {
+    accessKeyId?: string
+    secretAccessKey?: string,
+    sessionToken?: string
+  }
+}
+
+export interface ConfigurationParameters {
+    apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>);
+    username?: string;
+    password?: string;
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
+    awsv4?: AWSv4Configuration;
+    basePath?: string;
+    serverIndex?: number;
+    baseOptions?: any;
+    formDataCtor?: new () => any;
+}
+
+export class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     */
+    apiKey?: string | Promise<string> | ((name: string) => string) | ((name: string) => Promise<string>);
+    /**
+     * parameter for basic security
+     */
+    username?: string;
+    /**
+     * parameter for basic security
+     */
+    password?: string;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     */
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string) | ((name?: string, scopes?: string[]) => Promise<string>);
+    /**
+     * parameter for aws4 signature security
+     * @param {Object} AWS4Signature - AWS4 Signature security
+     * @param {string} options.region - aws region
+     * @param {string} options.service - name of the service.
+     * @param {string} credentials.accessKeyId - aws access key id
+     * @param {string} credentials.secretAccessKey - aws access key
+     * @param {string} credentials.sessionToken - aws session token
+     * @memberof Configuration
+     */
+    awsv4?: AWSv4Configuration;
+    /**
+     * override base path
+     */
+    basePath?: string;
+    /**
+     * override server index
+     */
+    serverIndex?: number;
+    /**
+     * base options for axios calls
+     */
+    baseOptions?: any;
+    /**
+     * The FormData constructor that will be used to create multipart form data
+     * requests. You can inject this here so that execution environments that
+     * do not support the FormData class can still run the generated client.
+     *
+     * @type {new () => FormData}
+     */
+    formDataCtor?: new () => any;
+
+    constructor(param: ConfigurationParameters = {}) {
+        this.apiKey = param.apiKey;
+        this.username = param.username;
+        this.password = param.password;
+        this.accessToken = param.accessToken;
+        this.awsv4 = param.awsv4;
+        this.basePath = param.basePath;
+        this.serverIndex = param.serverIndex;
+        this.baseOptions = {
+            ...param.baseOptions,
+            headers: {
+                ...param.baseOptions?.headers,
+            },
+        };
+        this.formDataCtor = param.formDataCtor;
+    }
+
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    public isJsonMime(mime: string): boolean {
+        const jsonMime: RegExp = /^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$/i;
+        return mime !== null && jsonMime.test(mime);
+    }
+}

src/generated/mammon/index.ts

@@ -0,0 +1,18 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export * from "./api";
+export * from "./configuration";
+

src/ledger/CreateLedgerModal.vue

@@ -0,0 +1,147 @@
+<script setup lang="ts">
+
+import {computed, ref} from "vue";
+import {storeToRefs} from "pinia";
+import {isCombined, Ledger, LedgerType, LedgerTypes, useLedgersStore} from "./ledger";
+import {Modal} from "@/components";
+import LedgerLabel from "./LedgerLabel.vue";
+import {PlusIcon, TrashIcon} from '@heroicons/vue/24/outline';
+import LedgerSelect from "@/ledger/LedgerSelect.vue";
+
+interface Props {
+  ledgerId?: string;
+}
+
+const props = defineProps<Props>();
+
+const ledgersStore = useLedgersStore();
+const {ledgers} = storeToRefs(ledgersStore);
+const {findById, findAllById, createMain, createCombined, updateMain, updateCombined} = ledgersStore;
+
+const modalOpen = ref<boolean>(false);
+
+const type = ref<LedgerType>(LedgerTypes.Main);
+const name = ref("");
+const members = ref<Ledger[]>([]);
+const selectedLedger = ref<Ledger>();
+const availableLedgers = computed(() => ledgers.value
+    .filter((ledger) => selectedLedger.value === ledger)
+    .filter(l => !members.value.includes(l)));
+
+
+const addMember = () => {
+  if (selectedLedger.value && !members.value.includes(selectedLedger.value)) {
+    members.value = [...members.value, selectedLedger.value];
+    selectedLedger.value = undefined;
+  }
+}
+
+const open = () => {
+  const ledger = isCreating.value ? undefined : findById(props.ledgerId);
+
+  if (ledger) {
+    type.value = ledger.type;
+    name.value = ledger.name;
+    members.value = isCombined(ledger) ? findAllById(ledger.memberLedgerIds) : [];
+  } else {
+    type.value = LedgerTypes.Main;
+    name.value = "";
+    members.value = [];
+  }
+  modalOpen.value = true;
+}
+
+const canSave = computed(() => name.value.trim().length > 0);
+const isCreating = computed(() => props.ledgerId === undefined || props.ledgerId.length === 0);
+const title = computed(() => {
+  if (isCreating.value) {
+    return `Creating ${type.value === LedgerTypes.Main ? 'Main' : 'Combined'} Ledger`
+  }
+  return `Updating ${name.value}`
+})
+
+const create = () => {
+  if (type.value === LedgerTypes.Main) {
+    createMain({name: name.value})
+  } else {
+    createCombined({name: name.value, memberLedgerIds: members.value.map(l => l.ledgerId)})
+  }
+}
+
+const update = () => {
+  if (type.value === LedgerTypes.Main) {
+    updateMain(props.ledgerId, {name: name.value})
+  } else {
+    updateCombined(props.ledgerId, {name: name.value, memberLedgerIds: members.value.map(l => l.ledgerId)})
+  }
+}
+
+const save = () => {
+  if (!canSave.value) {
+    return;
+  }
+
+  if (isCreating.value) {
+    create();
+  } else {
+    update();
+  }
+  modalOpen.value = false;
+}
+
+defineExpose({ open });
+</script>
+
+<template>
+  <Modal v-model:open="modalOpen">
+    <div class="bg-slate-800 rounded pb-4 w-96">
+      <span class="m-2">{{ title }}</span>
+      <hr />
+      <div class="mt-4">
+        <div class="flex justify-center">
+          <div class="flex bg-slate-600 rounded-s-md p-1">
+            <button class="switch" :class="{active: type === LedgerTypes.Main}" @click="type = LedgerTypes.Main">Main</button>
+          </div>
+          <div class="switch flex bg-slate-600 rounded-e-md p-1">
+            <button class="switch" :class="{active: type === LedgerTypes.Combined}" @click="type = LedgerTypes.Combined">Combined</button>
+          </div>
+        </div>
+        <div class="m-4">
+          Name:
+          <div class="flex">
+            <input type="text" class="flex grow" v-model="name" />
+          </div>
+        </div>
+      </div>
+      <div v-if="type === LedgerTypes.Combined" class="ms-4 mb-4">
+        Member Ledgers:
+        <div v-for="ledger in members" :key="ledger.ledgerId" class="flex">
+          <LedgerLabel class="flex grow mb-2" :ledger="ledger" />
+          <div class="flex justify-end me-4 ms-2">
+            <button class="btn-icon" @click="members = members.filter(m => m !== ledger)"><TrashIcon /></button>
+          </div>
+        </div>
+        <div v-if="availableLedgers.length" class="flex">
+          <LedgerSelect v-model="selectedLedger" class="grow" :ledgers="availableLedgers" />
+          <div class="flex justify-end me-4 ms-2">
+            <button class="btn-icon" @click="addMember"><PlusIcon /></button>
+          </div>
+        </div>
+      </div>
+      <div class="flex justify-end">
+        <button class="me-4" @click="save" :disabled="!canSave">Save</button>
+      </div>
+    </div>
+  </Modal>
+</template>
+
+<style scoped>
+@reference "tailwindcss";
+
+button.switch {
+  @apply flex items-center px-4 rounded-md bg-slate-600;
+  &.active {
+    @apply bg-emerald-500;
+  }
+}
+</style>

src/ledger/LedgerLabel.vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+
+import {isCombined, Ledger} from "@/ledger/ledger.ts";
+import {FolderOpenIcon} from '@heroicons/vue/24/outline';
+
+interface Props {
+  ledger: Ledger;
+}
+
+const props = defineProps<Props>();
+</script>
+
+<template>
+  <div class="flex">
+    <FolderOpenIcon v-if="isCombined(ledger)" class="w-4 me-1" />
+    <div v-else class="w-4 me-1"/>
+    <span>{{ ledger.name }}</span>
+  </div>
+</template>

src/ledger/LedgerSelect.vue

@@ -0,0 +1,34 @@
+<script setup lang="ts">
+import {Ledger, systemLedger, useLedgersStore} from "@/ledger/ledger.ts";
+import {storeToRefs} from "pinia";
+import {computed} from "vue";
+
+interface Props {
+  ledgers?: Ledger[];
+}
+
+const props = defineProps<Props>()
+const ledger = defineModel<Ledger>();
+const {ledgers: allLedgers} = storeToRefs(useLedgersStore());
+
+const ledgersToUse = computed(() => props.ledgers || allLedgers);
+const ledgerId = computed({
+  get: () => ledger.value?.ledgerId,
+  set: value => ledger.value = ledgersToUse.value.find(l => l.ledgerId === value)
+})
+
+</script>
+
+<template>
+  <select v-model="ledgerId" :class="{'system-ledger': ledger === systemLedger}">
+    <option v-for="l in ledgersToUse" :key="l.ledgerId" :value="l.ledgerId" :class="{'system-ledger': l === systemLedger}">{{ l.name }}</option>
+  </select>
+</template>
+
+<style scoped>
+@reference "tailwindcss";
+
+.system-ledger {
+  @apply text-emerald-400;
+}
+</style>

src/ledger/index.ts

@@ -0,0 +1,5 @@
+export * from './ledger';
+
+export {default as LedgerLabel} from './LedgerLabel.vue';
+export {default as LedgerSelect} from './LedgerSelect.vue';
+export {default as CreateLedgerModal} from './CreateLedgerModal.vue';

src/ledger/ledger.ts

@@ -0,0 +1,71 @@
+import {
+    CombinedLedgerResponse,
+    CombinedLedgerResponseTypeEnum,
+    CreateCombinedLedgerRequest,
+    CreateMainLedgerRequest,
+    LedgerResponseTypeEnum,
+    MainLedgerResponse,
+    MainLedgerResponseTypeEnum,
+    UpdateCombinedLedgerRequest,
+    UpdateMainLedgerRequest
+} from "@/generated/mammon";
+import {defineStore} from "pinia";
+import {ref, triggerRef} from "vue";
+import {ledgerControllerApi} from "@/mammon";
+
+export const LedgerTypes = LedgerResponseTypeEnum;
+
+export type LedgerType = LedgerResponseTypeEnum;
+export type MainLedger = MainLedgerResponse & {type: MainLedgerResponseTypeEnum}
+export type CombinedLedger = CombinedLedgerResponse & {type: CombinedLedgerResponseTypeEnum}
+export type Ledger = MainLedger | CombinedLedger;
+
+export const systemLedger = {
+    type: LedgerTypes.Main,
+    ledgerId: "",
+    name: "Eve Economy",
+    balance: 0,
+    _system: true
+} as MainLedger;
+
+export const isMain = (ledger: Ledger): ledger is MainLedger => {
+    return ledger.type === LedgerTypes.Main;
+}
+export const isCombined = (ledger: Ledger): ledger is CombinedLedger => {
+    return ledger.type === LedgerTypes.Combined;
+}
+
+export const useLedgersStore = defineStore('ledgers', () => {
+    const ledgers = ref<Ledger[]>([]);
+
+    const addLedger = (ledger: Ledger) => {
+        ledgers.value.push(ledger);
+        triggerRef(ledgers);
+        return ledger;
+    };
+
+    const replaceLedger = (ledger: Ledger) => {
+        const index = ledgers.value.findIndex(l => l.ledgerId === ledger.ledgerId);
+
+        if (index !== -1) {
+            ledgers.value[index] = ledger;
+        }
+        triggerRef(ledgers);
+        return ledger;
+    };
+
+    const findById = (ledgerId: string): Ledger | undefined => ledgers.value.find(l => l.ledgerId === ledgerId);
+    const findAllById = (ledgerIds: string[]): Ledger[] => ledgerIds.map(findById).filter((x): x is Ledger => x !== undefined)
+
+    const createMain = (ledger: CreateMainLedgerRequest) => ledgerControllerApi.createMainLedger(ledger).then(response => addLedger(response.data as Ledger));
+    const createCombined = (ledger: CreateCombinedLedgerRequest) => ledgerControllerApi.createCombinedLedger(ledger).then(response => addLedger(response.data as Ledger));
+    const updateMain = (ledgerId: string, ledger: UpdateMainLedgerRequest) => ledgerControllerApi.updateMainLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
+    const updateCombined = (ledgerId: string, ledger: UpdateCombinedLedgerRequest) => ledgerControllerApi.updateCombinedLedger(ledgerId, ledger).then(response => replaceLedger(response.data as Ledger));
+
+    const refresh = () => ledgerControllerApi.findAll().then(response => ledgers.value = response.data as Ledger[]);
+
+    refresh();
+
+    return {ledgers, findById, findAllById, createMain, createCombined, updateMain, updateCombined, refresh};
+})
+

src/main.ts

@@ -1,4 +1,3 @@
-import { useAuthStore } from "@/auth";
 import { createPinia } from 'pinia';
 import { createApp } from 'vue';
 import { createRouter, createWebHistory } from 'vue-router';
@@ -17,18 +16,6 @@ const router = createRouter({
 });
 
 app.use(pinia);
-
-const authStore = useAuthStore();
-
-router.beforeEach(async to => {
-    if (to.name === 'callback') {
-        await authStore.login();
-        return { name: 'home' };
-    } else if (!authStore.isLoggedIn) {
-        await authStore.redirect();
-    }
-});
-
 app.use(router);
 
 app.mount('#app');

src/mammon/index.ts

@@ -0,0 +1 @@
+export * from './mammonService'

src/mammon/mammonService.ts

@@ -0,0 +1,27 @@
+import {logResource} from "@/service";
+import axios from "axios";
+import {
+    ActivityControllerApi,
+    CharacterControllerApi,
+    LedgerControllerApi,
+    ProcessingControllerApi,
+    RuleBookControllerApi
+} from "@/generated/mammon";
+
+export const mammonUrl = import.meta.env.VITE_MAMMON_URL;
+export const mammonAddCharacterUrl = mammonUrl + "oauth2/authorization/esi"
+
+const mammonAxiosInstance = axios.create({
+    baseURL: mammonUrl,
+    headers: {
+        'Accept': 'application/json',
+        "Content-Type": "application/json",
+    },
+})
+logResource(mammonAxiosInstance)
+
+export const ledgerControllerApi = new LedgerControllerApi(undefined, mammonUrl, mammonAxiosInstance);
+export const characterControllerApi = new CharacterControllerApi(undefined, mammonUrl, mammonAxiosInstance);
+export const ruleBookControllerApi = new RuleBookControllerApi(undefined, mammonUrl, mammonAxiosInstance);
+export const activityControllerApi = new ActivityControllerApi(undefined, mammonUrl, mammonAxiosInstance);
+export const processingControllerApi = new ProcessingControllerApi(undefined, mammonUrl, mammonAxiosInstance);

src/marbas/MarbasObject.ts

@@ -1,3 +0,0 @@
-export type MarbasObject = {
-    id: number;
-}

src/marbas/index.ts

@@ -1,3 +0,0 @@
-export * from './MarbasObject';
-export * from './marbasService';
-

src/marbas/marbasService.ts

@@ -1,56 +0,0 @@
-import { useAuthStore } from "@/auth";
-import { logResource } from "@/service";
-import axios from "axios";
-
-export const marbasAxiosInstance = axios.create({
-    baseURL: import.meta.env.VITE_MARBAS_URL,
-    headers: {
-        'Accept': 'application/json',
-        "Content-Type": "application/json",
-    },
-})
-
-const authStore = useAuthStore();
-
-marbasAxiosInstance.interceptors.request.use(async r => {
-    if (!authStore.isLoggedIn) {
-        await authStore.redirect();
-    }
-
-    const accessToken = authStore.accessToken;
-
-    if (accessToken) {
-        r.headers.Authorization = `Bearer ${accessToken}`;
-    }
-    if (!r.params?.page_size) {
-        r.params = { ...r.params, page_size: 250 };
-    }
-    return r;
-})
-logResource(marbasAxiosInstance)
-marbasAxiosInstance.interceptors.response.use(async r => {
-    if (r.status === 401) {
-        await authStore.redirect();
-
-        return marbasAxiosInstance.request(r.config);
-    }
-
-    let next: string = r.data?.next;
-    let results = r.data?.results;
-
-    if (next) {
-        if (!next.startsWith(import.meta.env.VITE_MARBAS_URL)) { // FIME remove once the API is fixed
-            next = import.meta.env.VITE_MARBAS_URL + next.replace(/http(s)?:\/\/[^/]+\//g, '');
-        }
-
-        results = results.concat((await marbasAxiosInstance.request({
-            ...r.config,
-            url: next,
-            baseURL: '',
-        })).data);
-    }
-    if (results) {
-        r.data = results;
-    }
-    return r;
-})

src/market/acquisition/AcquisitionQuantilsTooltip.vue

@@ -1,10 +1,10 @@
 <script setup lang="ts">
-import { LoadingSpinner, Tooltip } from '@/components';
+import {LoadingSpinner, Tooltip} from '@/components';
-import { formatIsk } from '@/formaters';
+import {formatIsk} from '@/formaters';
-import { getHistory, getHistoryQuartils } from '@/market';
+import {getHistory, getHistoryQuartils} from '@/market';
-import { ArrowTrendingDownIcon, ArrowTrendingUpIcon } from '@heroicons/vue/24/outline';
+import {ArrowTrendingDownIcon, ArrowTrendingUpIcon} from '@heroicons/vue/24/outline';
-import { computedAsync } from '@vueuse/core';
+import {computedAsync} from '@vueuse/core';
-import { ref, watchEffect } from 'vue';
+import {ref, watchEffect} from 'vue';
 
 const trendingScale = 3;
 
@@ -74,7 +74,9 @@ watchEffect(async () => {
     </Tooltip>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
+
 .tooltip {
     @apply ms-auto;
     >:deep(div.header) {

src/market/acquisition/AcquisitionResultTable.vue

@@ -245,7 +245,8 @@ const total = computed(() => {
     </VirtualScrollTable>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 div.end {
     @apply justify-self-end ms-2;
 }

src/market/acquisition/BuyModal.vue

@@ -1,10 +1,9 @@
 <script setup lang="ts">
-import { Modal } from '@/components';
+import {Modal} from '@/components';
-import { formatIsk } from '@/formaters';
+import {formatIsk} from '@/formaters';
-import { MarketType, MarketTypeLabel } from '@/market';
+import {MarketType, MarketTypeLabel} from '@/market';
-import { ref } from 'vue';
+import {ref} from 'vue';
-import { useAcquiredTypesStore } from './acquisition';
+import {useAcquiredTypesStore} from './acquisition';
-
 
 const acquiredTypesStore = useAcquiredTypesStore();
 

src/market/acquisition/acquisition.ts

@@ -1,48 +1,16 @@
-import { marbasAxiosInstance, MarbasObject } from "@/marbas";
-import { AxiosResponse } from "axios";
-import log from "loglevel";
 import { defineStore } from "pinia";
 import { computed, ref } from "vue";
 
 export type AcquiredTypeSource = 'bo' | 'so' | 'prod' | 'misc';
 
-export type MarbasAcquiredType = MarbasObject & {
-    type: number;
-    quantity: number;
-    remaining: number;
-    price: number;
-    date: Date;
-    source: AcquiredTypeSource;
-}
-
-type RawMarbasAcquiredType =  Omit<MarbasAcquiredType, 'date'> & {
-    date: string;
-}
-
-type InsertableRawMarbasAcquiredType = Omit<MarbasAcquiredType, 'id' | 'date'>;
-
-const mapRawMarbasAcquiredType = (raw: RawMarbasAcquiredType): MarbasAcquiredType => ({
-    ...raw,
-    date: raw.date ? new Date(raw.date) : new Date()
-});
-
-const endpoint = '/api/acquisitions/';
-
 export const useAcquiredTypesStore = defineStore('market-acquisition', () => {
-    const acquiredTypes = ref<MarbasAcquiredType[]>([]);
+    const acquiredTypes = ref<any[]>([]); // TODO
 
     const types = computed(() => acquiredTypes.value.filter(item => item.remaining > 0));
     const addAcquiredType = async (type: number, quantity: number, price: number, source?: AcquiredTypeSource) => { 
-        const newItem = mapRawMarbasAcquiredType((await marbasAxiosInstance.post<RawMarbasAcquiredType, AxiosResponse<RawMarbasAcquiredType>, InsertableRawMarbasAcquiredType>(endpoint, {
+        const newItem = [];
-            type: type,
-            quantity: quantity,
-            remaining: quantity,
-            price: price,
-            source: source ?? 'misc', 
-        })).data);
 
         acquiredTypes.value = [...acquiredTypes.value, newItem];
-        log.info(`Acquired type ${newItem.id} with quantity ${newItem.quantity} and price ${newItem.price}`, newItem);
     };
     const removeAcquiredType = async (id: number, quantity: number) => {
         const found = acquiredTypes.value.find(t => t.id === id);
@@ -63,11 +31,9 @@ export const useAcquiredTypesStore = defineStore('market-acquisition', () => {
                 return i;
             }
         });
-        await marbasAxiosInstance.put(`${endpoint}${item.id}/`, item);
-        log.info(`Acquired type ${item.id} remaining: ${item.remaining}`, item);
     };
 
-    const refresh = () => marbasAxiosInstance.get<RawMarbasAcquiredType[]>(endpoint).then(res => acquiredTypes.value = res.data.map(mapRawMarbasAcquiredType));
+    const refresh = () => {}
 
     refresh();
 

src/market/tax/TaxInput.vue

@@ -17,7 +17,8 @@ const { brokerFee, scc } = storeToRefs(useMarketTaxStore());
     </div>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 div.end {
     @apply justify-self-end ms-2;
 }

src/market/tracking/TrackingResultTable.vue

@@ -167,7 +167,8 @@ const getLineColor = (result: Result) => {
     </VirtualScrollTable>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 div.end {
     @apply justify-self-end ms-2;
 }

src/market/tracking/tracking.ts

@@ -1,4 +1,3 @@
-import { marbasAxiosInstance, MarbasObject } from "@/marbas";
 import { EsiMarketOrderHistory, getHistory, MarketType, MarketTypePrice } from "@/market";
 import log from "loglevel";
 import { defineStore } from "pinia";
@@ -12,21 +11,16 @@ export type TrackingResult = {
     orderCount: number,
 }
 
-export type MarbasTrackedType = MarbasObject & {
-    type: number
-};
-
 const endpoint = '/api/types_tracking/';
 
 export const useMarketTrackingStore = defineStore('marketTracking', () => {
-    const trackedTypes = ref<MarbasTrackedType[]>([]);
+    const trackedTypes = ref<any[]>([]); // TODO
 
     const types = computed(() => trackedTypes.value.map(item => item.type) ?? []);
     const addType = async (type: number) => {
         const found = trackedTypes.value.find(item => item.type === type);
 
         if (!found) {
-            trackedTypes.value = [...trackedTypes.value, (await marbasAxiosInstance.post<MarbasTrackedType>(endpoint, { type })).data];
             log.info(`Tracking type ${type}`);
         }
     }
@@ -38,12 +32,8 @@ export const useMarketTrackingStore = defineStore('marketTracking', () => {
         }
 
         trackedTypes.value = trackedTypes.value.filter(t => t.id !== found.id);
-        await marbasAxiosInstance.delete(`${endpoint}${found.id}`);
-        log.info(`Stopped tracking type ${type}`);
     }
 
-    marbasAxiosInstance.get<MarbasTrackedType[]>(endpoint).then(res => trackedTypes.value = res.data);
-
     return { types, addType, removeType };
 });
 

src/market/type/MarketType.ts

@@ -1,5 +1,3 @@
-import { marbasAxiosInstance } from "@/marbas";
-
 export type MarketType = {
     id: number;
     group_id: number;
@@ -18,15 +16,9 @@ export const getMarketTypes = async (types: (string | number)[]): Promise<Market
     if (types.length === 0) {
         return [];
     } else if (types.length === 1 && typeof types[0] === "number") {
-        return [(await marbasAxiosInstance.get<MarketType>(`/sde/types/${types[0]}/`)).data];
+        return [];
     }
-    return (await marbasAxiosInstance.post<MarketType[]>("/api/types/search", types.map(t => {
+    return []
-        if (typeof t === "number") {
-            return { id: t };
-        } else {
-            return { name: t };
-        }
-    }))).data;
 }
 
 const blueprintMarketGrous = [ // TODO add all groups
@@ -49,9 +41,5 @@ const blueprintMarketGrous = [ // TODO add all groups
 ]
 
 export const searchMarketTypes = async (search: string): Promise<MarketType[]> => {
-    return (await marbasAxiosInstance.post<MarketType[]>("/api/types/search", [{
+    return []
-        name__icontains: search,
-        marketgroup_id___not: null,
-        marketgroup_id__in___not: blueprintMarketGrous,
-    }])).data;
 }

src/market/type/MarketTypeInput.vue

@@ -104,7 +104,8 @@ watchEffect(async () => {
     </div>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 .fake-input {
     @apply w-96 flex border bg-slate-500 rounded px-1 py-0.5;
 

src/market/type/MarketTypeLabel.vue

@@ -29,7 +29,8 @@ withDefaults(defineProps<Props>(), {
     </div>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
 button:deep(>svg), .button:deep(>svg) {
     @apply !w-4 !h-4;
 }

src/pages/Characters.vue

@@ -1,11 +1,27 @@
 <script setup lang="ts">
+
+import {mammonAddCharacterUrl} from "@/mammon";
+import {storeToRefs} from "pinia";
+import {CharacterLabel, useCharactersStore} from "@/characters";
+import {ArrowPathIcon} from '@heroicons/vue/24/outline';
+
+const charactersStore = useCharactersStore()
+const {characters} = storeToRefs(charactersStore);
+const {reloadActivities} = charactersStore;
+
 const addCharacter = () => {
-    // TODO
+    window.location.replace(mammonAddCharacterUrl);
 }
 </script>
 
 <template>
     <div class="grid mb-2 mt-4">
-        <button class="justify-self-end" @click="addCharacter">Add chacarcter</button>
+      <div class="mb-4 border-b-1 flex justify-end">
+        <button class="mb-2" @click="addCharacter">Add chacarcter</button>
+      </div>
+      <div v-for="character in characters" :key="character.characterId" class="flex items-center mb-2">
+        <CharacterLabel class="grow" :character="character" />
+        <button class="btn-icon" @click="reloadActivities(character.characterId)"><ArrowPathIcon /></button>
+      </div>
     </div>
 </template>

src/pages/Ledgers.vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import {RouterView} from 'vue-router';
+import {CreateLedgerModal} from "@/ledger";
+import {ref} from "vue";
+import {processingControllerApi} from "@/mammon";
+
+const createLedgerModal = ref<typeof CreateLedgerModal>();
+</script>
+
+<template>
+    <div class="mt-4">
+      <div class="mb-4 border-b-1 flex justify-end">
+        <button class="mb-2 ms-2" @click="processingControllerApi.processNewActivities()">Process Activities</button>
+        <button class="mb-2 ms-2" @click="createLedgerModal?.open()">New Ledger</button>
+      </div>
+      <CreateLedgerModal ref="createLedgerModal" />
+      <RouterView />
+    </div>
+</template>

src/pages/Market.vue

@@ -20,7 +20,9 @@ import { RouterLink, RouterView } from 'vue-router';
     </div>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
+
 a.tab {
     @apply flex items-center px-4 me-2 rounded-t-md bg-slate-600 hover:bg-slate-700;
     &.router-link-active {

src/pages/Rules.vue

@@ -0,0 +1,7 @@
+<script setup lang="ts">
+
+</script>
+
+<template>
+<RouterView />
+</template>

src/pages/ledger/ListLedgers.vue

@@ -0,0 +1,33 @@
+<script setup lang="ts">
+
+import {CreateLedgerModal, LedgerLabel, useLedgersStore} from "@/ledger";
+import {storeToRefs} from "pinia";
+import {nextTick, ref} from "vue";
+import {PencilSquareIcon} from "@heroicons/vue/24/outline";
+import {formatIsk} from "@/formaters.ts";
+
+const {ledgers} = storeToRefs(useLedgersStore());
+
+const editModal = ref<typeof CreateLedgerModal>();
+const editingLedgerId = ref("");
+
+const openEdit = async (ledgerId: string) => {
+  editingLedgerId.value = ledgerId;
+  await nextTick();
+  editModal.value?.open();
+};
+
+</script>
+
+<template>
+  <div class="mt-4">
+    <div v-for="ledger in ledgers" :key="ledger.ledgerId" class="flex items-center mb-2">
+      <LedgerLabel :ledger="ledger" />
+      <div class="flex grow">
+        <span class="ms-2">{{ formatIsk(ledger.balance) }}</span>
+      </div>
+      <button class="btn-icon ms-2" @click="openEdit(ledger.ledgerId)"><PencilSquareIcon /></button>
+    </div>
+  </div>
+  <CreateLedgerModal ref="editModal" :ledger-id="editingLedgerId" />
+</template>

src/pages/market/TypeInfo.vue

@@ -1,13 +1,13 @@
 <script setup lang="ts">
-import { ClipboardButton } from '@/components';
+import {ClipboardButton} from '@/components';
-import { MarketType, MarketTypeInput, getMarketType, useApraisalStore } from "@/market";
+import {getMarketType, MarketType, MarketTypeInput, useApraisalStore} from "@/market";
-import { AcquisitionResultTable, BuyModal, useAcquiredTypesStore } from '@/market/acquisition';
+import {AcquisitionResultTable, BuyModal, useAcquiredTypesStore} from '@/market/acquisition';
-import { TrackingResultTable, createResult, useMarketTrackingStore } from '@/market/tracking';
+import {createResult, TrackingResultTable, useMarketTrackingStore} from '@/market/tracking';
-import { BookmarkIcon, BookmarkSlashIcon, ShoppingCartIcon } from '@heroicons/vue/24/outline';
+import {BookmarkIcon, BookmarkSlashIcon, ShoppingCartIcon} from '@heroicons/vue/24/outline';
-import { computedAsync } from '@vueuse/core/index.cjs';
 import log from "loglevel";
-import { computed, ref, watch } from "vue";
+import {computed, ref, watch} from "vue";
-import { useRoute, useRouter } from "vue-router";
+import {useRoute, useRouter} from "vue-router";
+import {computedAsync} from "@vueuse/core";
 
 const buyModal = ref<typeof BuyModal>();
 
@@ -113,7 +113,9 @@ watch(useRoute(), async route => {
     <BuyModal ref="buyModal" />
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
+
 img.type-image {
     width: 64px;
     height: 64px;

src/pages/rules/EditRuleBook.vue

@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import {Character, CharacterLabel, useCharactersStore} from "@/characters";
+import {useRoute} from "vue-router";
+import {ref, watch, watchEffect} from "vue";
+import log from "loglevel";
+import {activityTypes, findByCharacterId, RuleBook, RuleInput, setCharacterRuleBook} from "@/rules";
+
+const {findById: findCharacterById} = useCharactersStore();
+const character = ref<Character>();
+
+const ruleBook = ref<RuleBook>();
+
+watchEffect(async () => {
+  const characterId = character.value?.characterId;
+
+  if (characterId) {
+    ruleBook.value = await findByCharacterId(characterId);
+  }
+});
+
+const save = () => {
+  const characterId = character.value?.characterId;
+
+  if (characterId && ruleBook.value) {
+    setCharacterRuleBook(characterId, ruleBook.value);
+  }
+}
+
+watch(useRoute(), async route => {
+  if (route.params.characterId) {
+    const id = parseInt(typeof route.params.characterId === 'string' ? route.params.characterId : route.params.characterId[0]);
+
+    character.value = await findCharacterById(id);
+    log.info('Loaded character:', character.value);
+  } else {
+    character.value = undefined;
+    log.info('No character to load');
+  }
+}, { immediate: true })
+</script>
+
+<template>
+  <div v-if="character" class="grid mb-2 mt-4">
+    <div class="mb-2 border-b-1 flex">
+      <CharacterLabel class="flex grow mb-2" :character="character" :size="64" />
+      <div>
+        <button @click="save">Save</button>
+      </div>
+    </div>
+    <div v-if="ruleBook" class="flex-col">
+      <div class="flex-col grow border-b-1" v-for="activityType in activityTypes" :key="activityType.key">
+        <span>{{ activityType.name }}</span>
+        <RuleInput v-model="ruleBook.rules[activityType.key]" />
+      </div>
+    </div>
+  </div>
+</template>

src/pages/rules/ListRuleBooks.vue

@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import {storeToRefs} from "pinia";
+import {CharacterLabel, useCharactersStore} from "@/characters";
+import {PencilSquareIcon} from "@heroicons/vue/24/outline";
+
+const {characters} = storeToRefs(useCharactersStore());
+
+</script>
+
+<template>
+  <div class="grid mb-2 mt-4">
+    <div v-for="character in characters" :key="character.characterId" class="flex items-center mb-2">
+      <CharacterLabel class="flex grow" :character="character" />
+      <RouterLink class="btn-icon ms-2" :to="{ name: 'character-rulebook', params: { characterId: character.characterId } }"><PencilSquareIcon /></RouterLink>
+    </div>
+  </div>
+</template>

src/reprocess/BuySellSlider.vue

@@ -12,7 +12,8 @@ const modelValue = defineModel({ default: false });
     </label>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
     input:checked ~ span:last-child {
         --tw-translate-x: 1.75rem;
     }

src/reprocess/reprocess.ts

@@ -1,5 +1,3 @@
-import { marbasAxiosInstance } from "@/marbas";
-
 export type ReprocessItemValues = {
     typeID: number;
     name: string;
@@ -22,7 +20,5 @@ export const reprocess = async (items: string, minerals: string, efficiency?: nu
     };
     const source = JSON.stringify(sourceJson);
 
-    const response = await marbasAxiosInstance.post('/reprocess/', source, {params: {efficiency: efficiency ?? 0.55}});
+    return []
-
-    return response.data;
 };

src/routes.ts

@@ -1,16 +1,29 @@
-import { RouteRecordRaw } from 'vue-router';
+import {RouteRecordRaw} from 'vue-router';
 
 export const routes: RouteRecordRaw[] = [
-    { path: '/', name: 'home', component: () => import('@/pages/Index.vue') },
+    {path: '/', name: 'home', component: () => import('@/pages/Index.vue')},
-    { path: '/callback', name: 'callback', component: () => import('@/pages/Index.vue') },
+    {path: '/callback', name: 'callback', component: () => import('@/pages/Index.vue')},
-    { path: '/reprocess', component: () => import('@/pages/Reprocess.vue') },
+
-    { path: '/market', component: () => import('@/pages/Market.vue'), children: [
+    {path: '/ledgers', component: () => import('@/pages/Ledgers.vue'), children: [
-        { path: '', redirect: '/market/types' },
+        {path: '', component: () => import('@/pages/ledger/ListLedgers.vue')},
-        { path: 'types/:type?', name: 'market-types', component: () => import('@/pages/market/TypeInfo.vue') },
+    ]},
-        { path: 'tracking', component: () => import('@/pages/market/Tracking.vue') },
+
-        { path: 'acquisitions', component: () => import('@/pages/market/Acquisitions.vue') },
+    {path: '/rules', component: () => import('@/pages/Rules.vue'), children: [
-    ] },
+        {path: '', component: () => import('./pages/rules/ListRuleBooks.vue')},
-    { path: '/tools', component: () => import('@/pages/Tools.vue') },
+        {path: '/characters/:characterId/rule-book', name: 'character-rulebook', component: () => import('@/pages/rules/EditRuleBook.vue')},
-    { path: '/characters', component: () => import('@/pages/Characters.vue') },
+    ]},
-    { path: '/about', name: 'about', component: () => import('@/pages/About.vue') },
+
+    {path: '/market', component: () => import('@/pages/Market.vue'), children: [
+        {path: '', redirect: '/market/types'},
+        {path: 'types/:type?', name: 'market-types', component: () => import('@/pages/market/TypeInfo.vue')},
+        {path: 'tracking', component: () => import('@/pages/market/Tracking.vue')},
+        {path: 'acquisitions', component: () => import('@/pages/market/Acquisitions.vue')},
+    ]},
+
+    {path: '/reprocess', component: () => import('@/pages/Reprocess.vue')},
+
+    {path: '/tools', component: () => import('@/pages/Tools.vue')},
+
+    {path: '/characters', component: () => import('@/pages/Characters.vue')},
+    {path: '/about', name: 'about', component: () => import('@/pages/About.vue')},
 ];

src/rules/RuleClauseInput.vue

@@ -0,0 +1,37 @@
+<script setup lang="ts">
+
+import {RuleClauseResponse} from "@/generated/mammon";
+import {computed} from "vue";
+import {isMain, Ledger, LedgerSelect, systemLedger, useLedgersStore} from "@/ledger";
+import {ratesTypes} from "@/rules/rules.ts";
+
+const rule = defineModel<RuleClauseResponse>();
+
+const ledgersStore = useLedgersStore();
+const {findById} = ledgersStore;
+const ledgers = computed<Ledger[]>(() => [systemLedger, ...ledgersStore.ledgers.filter(isMain)]);
+
+const ledgerComputed = (key: 'fromLedgerId' | 'toLedgerId') => computed<Ledger>({
+  get: () => rule.value && rule.value[key] ? findById(rule.value[key]) ?? systemLedger : systemLedger,
+  set: value => {
+    if (value) {
+      rule.value = {...rule.value, [key]: value.ledgerId.length ? value.ledgerId : undefined}
+    }
+  }
+})
+
+const fromLedger = ledgerComputed('fromLedgerId')
+const toLedger = ledgerComputed('toLedgerId')
+
+</script>
+
+<template>
+  From:
+ <LedgerSelect class="me-2 grow" v-model="fromLedger" :ledgers="ledgers" />
+  To:
+ <LedgerSelect class="me-2 grow" v-model="toLedger" :ledgers="ledgers" />
+  At:
+  <select class="me-2 grow" v-model="rule.rate">
+    <option v-for="rateType in ratesTypes" :key="rateType.key" :value="rateType.key">{{ rateType.name }}</option>
+  </select>
+</template>

src/rules/RuleInput.vue

@@ -0,0 +1,65 @@
+<script setup lang="ts">
+
+import {RuleClauseResponse, RuleClauseResponseRateEnum, RuleResponse} from "@/generated/mammon";
+import RuleClauseInput from "@/rules/RuleClauseInput.vue";
+import {computed, useTemplateRef} from "vue";
+import {Bars4Icon, PlusIcon, TrashIcon} from '@heroicons/vue/24/outline';
+import {useSortable} from "@vueuse/integrations/useSortable";
+
+const rule = defineModel<RuleResponse>();
+const rules = computed<RuleClauseResponse[]>({
+  get: () =>  rule.value && rule.value.rules ? rule.value.rules : [],
+  set: value => rule.value = {rules: value}
+})
+
+const addRule = () => {
+  rules.value = [...rules.value, {rate: RuleClauseResponseRateEnum.None}]
+}
+
+const setRule = (index: number, rule?: RuleClauseResponse) => {
+  if (!rule) {
+    return;
+  }
+  rules.value = rules.value.with(index, rule)
+}
+
+const removeRule = (index: number) => {
+  rules.value = rules.value.toSpliced(index, 1)
+}
+
+const sortableContainer = useTemplateRef('sortable-container')
+useSortable(sortableContainer, rules, { handle: '.sortable-handle'});
+</script>
+
+<template>
+<div class="flex-col">
+  <div ref="sortable-container" class="flex-col">
+    <div class="flex items-end gap-2 mt-2" v-for="(rule, index) in rules" :key="index">
+      <span class="sortable-handle flex">
+        <Bars4Icon class="w-6"/>
+      </span>
+      <RuleClauseInput :modelValue="rule" @update:modelValue="v => setRule(index, v)" />
+      <button class="btn-icon" @click="removeRule(index)"><TrashIcon /></button>
+    </div>
+  </div>
+  <div class="flex justify-end mb-2 mt-2">
+    <button class="btn-icon" @click="addRule"><PlusIcon /></button>
+  </div>
+</div>
+</template>
+
+<style scoped>
+
+.sortable-handle {
+  @apply cursor-grab;
+}
+
+.sortable-chosen {
+  @apply cursor-grabbing;
+}
+
+.sortable-chosen .sortable-handle {
+  @apply cursor-grabbing;
+}
+
+</style>

src/rules/index.ts

@@ -0,0 +1,3 @@
+export * from "./rules";
+
+export {default as RuleInput} from './RuleInput.vue';

src/rules/rules.ts

@@ -0,0 +1,30 @@
+import {ruleBookControllerApi} from "@/mammon";
+import {RuleBookResponse, RuleClauseResponseRateEnum, RuleResponse} from "@/generated/mammon";
+
+export const activityTypes = {
+    itemBought: {key: "ITEM_BOUGHT", name: "Item Bought"},
+    itemSold: {key: "ITEM_SOLD", name: "Item Sold"},
+    // bountyEarned:  {id: "BOUNTY_EARNED", name: "Bounty Earned"},
+    // itemManufactured:  {id: "ITEM_MANUFACTURED", name: "Item Manufactured"}
+} as const;
+
+export type Activity = { key: ActivityType, name: string }
+export type ActivityType = typeof activityTypes[keyof typeof activityTypes]['key'];
+export type RuleBook = RuleBookResponse & { rules: { [key: ActivityType]: RuleResponse; } }
+
+export const ratesTypes = {
+    None: {key: "NONE", name: "0 ISK"},
+    Value: {key: "VALUE", name: "Value"},
+    JitaBuy: {key: "JITA_BUY", name: "Jita Buy Order"},
+    JitaSell: {key: "JITA_SELL", name: "Jita Sell Order"},
+    EveEstimate: {key: "EVE_ESTIMATE", name: "Eve Estimate"},
+} as const;
+
+export type Rate = { key: RuleClauseResponseRateEnum, name: string }
+
+export const findByCharacterId = (characterId: number): Promise<RuleBook> => ruleBookControllerApi.findByCharacterId(characterId)
+    .then(response => response.data)
+    .catch(() => ({characterId, rules: {}}));
+
+export const setCharacterRuleBook = (characterId: number, ruleBook: RuleBook): Promise<RuleBook> => ruleBookControllerApi.setCharacterRuleBook(characterId, ruleBook)
+    .then(response => response.data);

src/sidebar/Sidebar.vue

@@ -1,73 +1,80 @@
 <script setup lang="ts">
-import { useAuthStore } from '@/auth';
+import {Dropdown} from '@/components';
-import { Dropdown } from '@/components';
+import {RouterLink} from 'vue-router';
-import { RouterLink } from 'vue-router';
 
 const links = [
-    { name: "Market", path: "/market" },
+  {name: "Ledger", path: "/ledgers"},
-    { name: "Reprocess", path: "/reprocess" },
+  {name: "Rules", path: "/rules"},
-    { name: "Tools", path: "/tools" }
+  {name: "Market", path: "/market"},
+  {name: "Reprocess", path: "/reprocess"},
+  {name: "Tools", path: "/tools"}
 ];
 
-const authStore = useAuthStore();
 
 const logout = async () => {
-    await authStore.logout();
 }
 </script>
 
 <template>
-    <aside class="fixed top-0 left-0 w-64 h-screen transition-transform -translate-x-full sm:translate-x-0">
+  <aside class="fixed top-0 left-0 w-64 h-screen transition-transform -translate-x-full sm:translate-x-0">
-        <div class="h-full px-3 py-4 overflow-y-auto bg-slate-700 flex flex-col">
+    <div class="h-full px-3 py-4 overflow-y-auto bg-slate-700 flex flex-col">
-            <div class="mb-2 border-b-2 border-emerald-500">
+      <div class="mb-2 border-b-2 border-emerald-500">
-                <Dropdown class="mb-2 user-dropdown">
+        <Dropdown class="mb-2 user-dropdown">
-                    <template #button>
+          <template #button>
-                        <span>{{ authStore.username }}</span>
+            <span>NAME</span>
-                    </template>
+          </template>
-                    <ul>
+          <ul>
-                        <li>
+            <li>
-                            <RouterLink class="sidebar-button py-0.5 px-2" to="/characters">Characters</RouterLink>
+              <RouterLink class="sidebar-button py-0.5 px-2" to="/characters">Characters</RouterLink>
-                        </li>
+            </li>
-                        <li>
+            <li>
-                            <RouterLink class="sidebar-button py-0.5 px-2" :to="{name: 'about'}">About EVE Online</RouterLink>
+              <RouterLink class="sidebar-button py-0.5 px-2" :to="{name: 'about'}">About EVE Online</RouterLink>
-                        </li>
+            </li>
-                        <li>
+            <li>
-                            <a class="sidebar-button py-0.5 px-2 text-amber-700" @click="logout">Logout</a>
+              <a class="sidebar-button py-0.5 px-2 text-amber-700" @click="logout">Logout</a>
-                        </li>
+            </li>
-                    </ul>
+          </ul>
-                </Dropdown>
+        </Dropdown>
-            </div>
+      </div>
-            <ul class="space-y-2 font-medium">
+      <ul class="space-y-2 font-medium">
-                <li v-for="link in links" :key="link.name">
+        <li v-for="link in links" :key="link.name">
-                    <RouterLink :to="link.path" class="sidebar-button p-2">
+          <RouterLink :to="link.path" class="sidebar-button p-2">
-                        <span>{{ link.name }}</span>
+            <span>{{ link.name }}</span>
-                    </RouterLink>
+          </RouterLink>
-                </li>
+        </li>
-            </ul>
+      </ul>
-        </div>
+    </div>
-    </aside>
+  </aside>
 </template>
 
-<style scoped lang="postcss">
+<style scoped>
+@reference "tailwindcss";
+
 .sidebar-button {
-    @apply flex items-center rounded-md hover:bg-slate-800 cursor-pointer;
+  @apply flex items-center rounded-md hover:bg-slate-800 cursor-pointer;
 }
+
 .router-link-active {
-    @apply bg-emerald-500 hover:bg-emerald-700;
+  @apply bg-emerald-500 hover:bg-emerald-700;
 }
+
 .user-dropdown {
-    @apply w-full;
+  @apply w-full;
-    :deep(>div) {
+}
-        @apply w-full;
+
-        >div {
+.user-dropdown :deep(>div) {
-            @apply w-full bg-slate-800;
+  @apply w-full;
-        }
+
-    }
+  > div {
-    :deep(>button) {
+    @apply w-full bg-slate-800;
-        @apply bg-slate-700 hover:bg-slate-800 border-none flex items-center w-full;
+  }
-    }
+}
-    &.dropdown-open:deep(>button) {
+
-        @apply bg-slate-800 rounded-b-none;
+.user-dropdown :deep(>button) {
-    }
+  @apply bg-slate-700 hover:bg-slate-800 border-none flex items-center w-full;
+}
+
+.user-dropdown.dropdown-open :deep(>button) {
+  @apply bg-slate-800 rounded-b-none;
 }
 </style>

src/style.css

@@ -1,9 +1,9 @@
-@tailwind base;
+@import "tailwindcss";
-@tailwind components;
+
-@tailwind utilities;
+@custom-variant search-cancel (&::-webkit-search-cancel-button);
 
 @layer base {
-    span, table, input, th, tr, td, button, div, hr {
+    span, table, input, th, tr, td, button, a.button, div, hr {
         @apply border-slate-600 text-slate-100 placeholder-slate-400;
     }
 
@@ -11,12 +11,15 @@
         @apply bg-slate-800;
     }
 
-    button {
+    button, a.button {
         @apply py-0.5 px-2 border rounded bg-slate-600 hover:bg-slate-700;
     }
-    input {
+    input, select {
         @apply border bg-slate-500 rounded px-1;
     }
+    option {
+        @apply bg-slate-500;
+    }
     textarea {
         @apply border rounded bg-slate-500 w-full;
     }

src/utils.ts

@@ -1 +1 @@
-export const copyToClipboard = (s: string) => navigator.clipboard.writeText(s);
+export const copyToClipboard = (s: string) => navigator.clipboard.writeText(s);

tailwind.config.js

@@ -1,16 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
-  content: [
-    "./index.html",
-    "./src/**/*.{vue,js,ts,jsx,tsx}",
-  ],
-  theme: {
-    extend: {},
-  },
-  plugins: [
-    require('tailwindcss/plugin')(({ addVariant }) => {
-      addVariant('search-cancel', '&::-webkit-search-cancel-button');
-    }),
-  ],
-}
-

tsconfig.json

@@ -26,7 +26,8 @@
       "src/*": [
         "./src/*"
       ]
-    }
+    },
+    "allowSyntheticDefaultImports": true
   },
   "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"],
   "references": [{ "path": "./tsconfig.node.json" }]

vite.config.ts

@@ -2,11 +2,13 @@ import vue from '@vitejs/plugin-vue';
 import * as path from "path";
 import { defineConfig } from 'vite';
 import runtimeEnv from 'vite-plugin-runtime-env';
+import tailwindcss from '@tailwindcss/vite'
 
 export default defineConfig({
     plugins: [
         runtimeEnv(),
         vue(),
+        tailwindcss(),
     ],
     resolve: {
         alias: {