@wisemen/wise-crm-web 0.0.0-alpha.0

package/dist/api/mutations/individual/individualUpdate.mutation.d.ts

@@ -0,0 +1,27 @@
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+interface Params {
+    uuid: IndividualUuid;
+}
+export declare function useIndividualUpdateMutation(): import("@wisemen/vue-core-query").UseMutationReturnType<{
+    birthDate: import("temporal-polyfill").Temporal.PlainDate | null;
+    address: {
+        bus: string;
+        city: string;
+        coordinates: {
+            lat: number | null;
+            lng: number | null;
+        };
+        country: string;
+        postalCode: string;
+        street: string;
+        streetNumber: string;
+    };
+    customFields: Record<string, unknown> | null;
+    email: string | null;
+    firstName: string;
+    lastName: string;
+    mobilePhone: string | null;
+    phone: string | null;
+    socialSecurityNumber: string | null;
+}, void, Params>;
+export {};

package/dist/api/mutations/noteBusinessCreate.mutation.d.ts

@@ -0,0 +1,8 @@
+import type { BusinessUuid } from '@/models/business/businessUuid.model';
+interface Params {
+    businessUuid: BusinessUuid;
+}
+export declare function useNoteBusinessCreateMutation(): import("@wisemen/vue-core-query").UseMutationReturnType<{
+    note: string;
+}, void, Params>;
+export {};

package/dist/api/mutations/noteDelete.mutation.d.ts

@@ -0,0 +1,10 @@
+import type { BusinessUuid } from '@/models/business/businessUuid.model';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model';
+import type { NoteUuid } from '@/models/notes/noteUuid.model.ts';
+interface Params {
+    businessUuid?: BusinessUuid;
+    individualUuid?: IndividualUuid;
+    noteUuid: NoteUuid;
+}
+export declare function useNoteDeleteMutation(): import("@wisemen/vue-core-query").UseMutationReturnType<void, void, Params>;
+export {};

package/dist/api/mutations/noteIndividualCreate.mutation.d.ts

@@ -0,0 +1,8 @@
+import type { UseMutationReturnType } from '@wisemen/vue-core-query';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model';
+import type { NoteFormData } from '@/models/notes/create/noteCreateForm.model.ts';
+interface Params {
+    individualUuid: IndividualUuid;
+}
+export declare function useNoteIndividualCreateMutation(): UseMutationReturnType<NoteFormData, void, Params>;
+export {};

package/dist/api/mutations/noteUpdate.mutation.d.ts

@@ -0,0 +1,13 @@
+import type { BusinessUuid } from '@/models/business/businessUuid.model';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model';
+import type { NoteUuid } from '@/models/notes/noteUuid.model.ts';
+interface Body {
+    note: string;
+}
+interface Params {
+    businessUuid?: BusinessUuid;
+    individualUuid?: IndividualUuid;
+    noteUuid: NoteUuid;
+}
+export declare function useNoteUpdateMutation(): import("@wisemen/vue-core-query").UseMutationReturnType<Body, void, Params>;
+export {};

package/dist/api/queries/board/boardColumnsIndex.query.d.ts

@@ -0,0 +1,2 @@
+import type { BoardColumn } from '@/models/board/boardColumn.model.ts';
+export declare function useBoardColumnsIndexQuery(): import("@wisemen/vue-core-query").UseQueryReturnType<BoardColumn[]>;

package/dist/api/queries/business/businessActivityIndex.query.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationOptions } from '@wisemen/vue-core-components';
+import type { UseInfiniteQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { ActivityIndex } from '@/models/activity/activityIndex.model.ts';
+import type { ActivityIndexPagination } from '@/models/activity/activityIndexPagination.model.ts';
+import type { BusinessUuid } from '@/models/business/businessUuid.model';
+export declare function useBusinessActivityIndexQuery(businessUuid: ComputedRef<BusinessUuid>, paginationOptions: ComputedRef<PaginationOptions<ActivityIndexPagination>>): UseInfiniteQueryReturnType<ActivityIndex>;

package/dist/api/queries/business/businessBillingInformation.query.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { BusinessBillingInformation } from '@/models/business/billing-information/businessBillingInformation.model';
+import type { BusinessUuid } from '@/models/business/businessUuid.model';
+export declare function useBusinessBillingInformationQuery(businessUuid: ComputedRef<BusinessUuid>, isEnabled: ComputedRef<boolean>): UseQueryReturnType<BusinessBillingInformation>;

package/dist/api/queries/business/businessContactPersonDetail.query.d.ts

@@ -0,0 +1,6 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { BusinessUuid } from '@/models/business/businessUuid.model.ts';
+import type { BusinessContactPersonDetail } from '@/models/business/contact-person/businessContactPersonDetail.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+export declare function useBusinessContactPersonDetailQuery(businessUuid: ComputedRef<BusinessUuid | null>, contactPersonUuid: ComputedRef<IndividualUuid | null>): UseQueryReturnType<BusinessContactPersonDetail>;

package/dist/api/queries/business/businessDetail.query.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { BusinessUuid } from '@/models/business/businessUuid.model.ts';
+import type { BusinessDetail } from '@/models/business/detail/businessDetail.model.ts';
+export declare function useBusinessDetailQuery(businessUuid: ComputedRef<BusinessUuid | null>): UseQueryReturnType<BusinessDetail>;

package/dist/api/queries/business/businessIndex.query.d.ts

@@ -0,0 +1,5 @@
+import type { PaginationOptions } from '@wisemen/vue-core-components';
+import type { ComputedRef } from 'vue';
+import type { BusinessIndex } from '@/models/business/index/businessIndex.model.ts';
+import type { BusinessIndexPagination } from '@/models/business/index/businessIndexPagination.model.ts';
+export declare function useBusinessIndexQuery(paginationOptions: ComputedRef<PaginationOptions<BusinessIndexPagination>>, isEnabled?: ComputedRef<boolean>): import("@wisemen/vue-core-query").UseInfiniteQueryReturnType<BusinessIndex>;

package/dist/api/queries/business/businessStatistics.query.d.ts

@@ -0,0 +1,3 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { BusinessStatistics } from '@/models/business/statistics/businessStatistics.model.ts';
+export declare function useBusinessStatisticsQuery(): UseQueryReturnType<BusinessStatistics>;

package/dist/api/queries/cbe/cbeEnterpriseSearchByTerm.query.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedRef } from 'vue';
+import type { CbeEnterpriseSearch } from '@/models/cbe/search/cbeEnterpriseSearch.model.ts';
+export declare function useCbeEnterpriseSearchByTermQuery(searchTerm: ComputedRef<string>): import("@wisemen/vue-core-query").UseQueryReturnType<CbeEnterpriseSearch[]>;

package/dist/api/queries/customFieldDefinitionIndex.query.d.ts

@@ -0,0 +1,4 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { CustomFieldDefinitionIndex } from '@/models/custom-field-definition/customFieldDefinitionIndex.model.ts';
+import type { EntityType } from '@/models/enitityType.model.ts';
+export declare function useCustomFieldDefinitionIndexQuery(entityType: EntityType): UseQueryReturnType<CustomFieldDefinitionIndex[]>;

package/dist/api/queries/deal/dealContactPersonDetail.query.d.ts

@@ -0,0 +1,5 @@
+import type { ComputedRef } from 'vue';
+import type { DealContactPersonDetail } from '@/models/deal/contact-person/dealContactPersonDetail.model.ts';
+import type { DealUuid } from '@/models/deal/dealUuid.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+export declare function useDealContactPersonDetailQuery(dealUuid: ComputedRef<DealUuid>, contactPersonUuid: ComputedRef<IndividualUuid>): import("@wisemen/vue-core-query").UseQueryReturnType<DealContactPersonDetail>;

package/dist/api/queries/deal/dealDetail.query.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef } from 'vue';
+import type { DealUuid } from '@/models/deal/dealUuid.model.ts';
+import type { DealDetail } from '@/models/deal/detail/dealDetail.model.ts';
+export declare function useDealDetailQuery(dealUuid: ComputedRef<DealUuid>): import("@wisemen/vue-core-query").UseQueryReturnType<DealDetail>;

package/dist/api/queries/deal/dealIndex.query.d.ts

@@ -0,0 +1,220 @@
+import type { DealIndex } from '@/models/deal/index/dealIndex.model.ts';
+import type { DealIndexQueryParams } from '@/models/deal/index/dealIndexQueryParams.model';
+import type { InfiniteQueryOptions } from '@/types/query.type';
+export declare function useDealIndexQuery(params: InfiniteQueryOptions<DealIndexQueryParams>): {
+    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>>;
+    fetchNextPage: () => Promise<void>;
+    error: import("vue").Ref<Error, Error>;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"error", "error">;
+    fetchPreviousPage: (options?: import("@tanstack/vue-query").FetchPreviousPageOptions) => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    hasNextPage: import("vue").Ref<boolean, boolean>;
+    hasPreviousPage: import("vue").Ref<boolean, boolean>;
+    isFetchNextPageError: import("vue").Ref<boolean, boolean>;
+    isFetchingNextPage: import("vue").Ref<boolean, boolean>;
+    isFetchPreviousPageError: import("vue").Ref<boolean, boolean>;
+    isFetchingPreviousPage: import("vue").Ref<boolean, boolean>;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    isEnabled: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>>;
+    fetchNextPage: () => Promise<void>;
+    error: import("vue").Ref<null, null>;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isFetchNextPageError: import("vue").Ref<false, false>;
+    isFetchPreviousPageError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"success", "success">;
+    fetchPreviousPage: (options?: import("@tanstack/vue-query").FetchPreviousPageOptions) => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    hasNextPage: import("vue").Ref<boolean, boolean>;
+    hasPreviousPage: import("vue").Ref<boolean, boolean>;
+    isFetchingNextPage: import("vue").Ref<boolean, boolean>;
+    isFetchingPreviousPage: import("vue").Ref<boolean, boolean>;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    isEnabled: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>>;
+    fetchNextPage: () => Promise<void>;
+    error: import("vue").Ref<Error, Error>;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<true, true>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isFetchNextPageError: import("vue").Ref<false, false>;
+    isFetchPreviousPageError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"error", "error">;
+    fetchPreviousPage: (options?: import("@tanstack/vue-query").FetchPreviousPageOptions) => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    hasNextPage: import("vue").Ref<boolean, boolean>;
+    hasPreviousPage: import("vue").Ref<boolean, boolean>;
+    isFetchingNextPage: import("vue").Ref<boolean, boolean>;
+    isFetchingPreviousPage: import("vue").Ref<boolean, boolean>;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    isEnabled: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>>;
+    fetchNextPage: () => Promise<void>;
+    error: import("vue").Ref<null, null>;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isLoading: import("vue").Ref<true, true>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isFetchNextPageError: import("vue").Ref<false, false>;
+    isFetchPreviousPageError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"pending", "pending">;
+    fetchPreviousPage: (options?: import("@tanstack/vue-query").FetchPreviousPageOptions) => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    hasNextPage: import("vue").Ref<boolean, boolean>;
+    hasPreviousPage: import("vue").Ref<boolean, boolean>;
+    isFetchingNextPage: import("vue").Ref<boolean, boolean>;
+    isFetchingPreviousPage: import("vue").Ref<boolean, boolean>;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    isEnabled: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>>;
+    fetchNextPage: () => Promise<void>;
+    error: import("vue").Ref<null, null>;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isFetchNextPageError: import("vue").Ref<false, false>;
+    isFetchPreviousPageError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    isPlaceholderData: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"pending", "pending">;
+    fetchPreviousPage: (options?: import("@tanstack/vue-query").FetchPreviousPageOptions) => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    hasNextPage: import("vue").Ref<boolean, boolean>;
+    hasPreviousPage: import("vue").Ref<boolean, boolean>;
+    isFetchingNextPage: import("vue").Ref<boolean, boolean>;
+    isFetchingPreviousPage: import("vue").Ref<boolean, boolean>;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    isEnabled: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>>;
+    fetchNextPage: () => Promise<void>;
+    isError: import("vue").Ref<false, false>;
+    error: import("vue").Ref<null, null>;
+    isPending: import("vue").Ref<false, false>;
+    isLoading: import("vue").Ref<false, false>;
+    isLoadingError: import("vue").Ref<false, false>;
+    isRefetchError: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    isPlaceholderData: import("vue").Ref<true, true>;
+    isFetchNextPageError: import("vue").Ref<false, false>;
+    isFetchPreviousPageError: import("vue").Ref<false, false>;
+    status: import("vue").Ref<"success", "success">;
+    fetchPreviousPage: (options?: import("@tanstack/vue-query").FetchPreviousPageOptions) => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    hasNextPage: import("vue").Ref<boolean, boolean>;
+    hasPreviousPage: import("vue").Ref<boolean, boolean>;
+    isFetchingNextPage: import("vue").Ref<boolean, boolean>;
+    isFetchingPreviousPage: import("vue").Ref<boolean, boolean>;
+    dataUpdatedAt: import("vue").Ref<number, number>;
+    errorUpdatedAt: import("vue").Ref<number, number>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    errorUpdateCount: import("vue").Ref<number, number>;
+    isFetched: import("vue").Ref<boolean, boolean>;
+    isFetchedAfterMount: import("vue").Ref<boolean, boolean>;
+    isFetching: import("vue").Ref<boolean, boolean>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    isRefetching: import("vue").Ref<boolean, boolean>;
+    isStale: import("vue").Ref<boolean, boolean>;
+    isEnabled: import("vue").Ref<boolean, boolean>;
+    refetch: (options?: import("@tanstack/vue-query").RefetchOptions) => Promise<import("@tanstack/vue-query").QueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+    fetchStatus: import("vue").Ref<import("@tanstack/vue-query").FetchStatus, import("@tanstack/vue-query").FetchStatus>;
+    promise: import("vue").Ref<Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<DealIndex>, unknown>, Error>>;
+};

package/dist/api/queries/globalSearch.queries.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { GlobalSearchCollectionName } from '@/client';
+import type { GlobalSearchItem } from '@/models/global-search/globalSearchItem.model';
+export declare function useGlobalSearchQuery(search: ComputedRef<string>, collections: ComputedRef<GlobalSearchCollectionName[]>): UseQueryReturnType<GlobalSearchItem[]>;

package/dist/api/queries/individual/individualActivityIndex.query.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationOptions } from '@wisemen/vue-core-components';
+import type { UseInfiniteQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { ActivityIndex } from '@/models/activity/activityIndex.model.ts';
+import type { ActivityIndexPagination } from '@/models/activity/activityIndexPagination.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model';
+export declare function useActivityIndividualIndexQuery(individualUuid: ComputedRef<IndividualUuid>, paginationOptions: ComputedRef<PaginationOptions<ActivityIndexPagination>>): UseInfiniteQueryReturnType<ActivityIndex>;

package/dist/api/queries/individual/individualBillingInformation.query.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { IndividualBillingInformation } from '@/models/individual/billing-information/individualBillingInformation.model';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model';
+export declare function useIndividualBillingInformationQuery(individualUuid: ComputedRef<IndividualUuid | null>, hasBillingInformation: ComputedRef<boolean>): UseQueryReturnType<IndividualBillingInformation>;

package/dist/api/queries/individual/individualContactPersonDetail.query.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { IndividualContactPersonDetail } from '@/models/individual/contact-person/individualContactPersonDetail.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+export declare function useIndividualContactPersonDetailQuery(individualUuid: ComputedRef<IndividualUuid | null>, contactPersonUuid: ComputedRef<IndividualUuid | null>): UseQueryReturnType<IndividualContactPersonDetail>;

package/dist/api/queries/individual/individualDetail.query.d.ts

@@ -0,0 +1,5 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { IndividualDetail } from '@/models/individual/detail/individualDetail.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+export declare function useIndividualDetailQuery(individualUuid: ComputedRef<IndividualUuid | null>): UseQueryReturnType<IndividualDetail>;

package/dist/api/queries/individual/individualIndex.query.d.ts

@@ -0,0 +1,5 @@
+import type { PaginationOptions } from '@wisemen/vue-core-components';
+import type { ComputedRef } from 'vue';
+import type { IndividualIndex } from '@/models/individual/index/individualIndex.model.ts';
+import type { IndividualIndexPagination } from '@/models/individual/index/individualIndexPagination.model.ts';
+export declare function useIndividualIndexQuery(paginationOptions: ComputedRef<PaginationOptions<IndividualIndexPagination>>): import("@wisemen/vue-core-query").UseInfiniteQueryReturnType<IndividualIndex>;

package/dist/api/queries/individual/individualStatistics.query.d.ts

@@ -0,0 +1,3 @@
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { IndividualStatistics } from '@/models/individual/statistics/individualStatistics.model.ts';
+export declare function useIndividualStatisticsQuery(): UseQueryReturnType<IndividualStatistics>;

package/dist/api/queries/noteBusinessIndex.query.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationOptions } from '@wisemen/vue-core-components';
+import type { UseInfiniteQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { BusinessUuid } from '@/models/business/businessUuid.model';
+import type { NoteIndex } from '@/models/notes/index/noteIndex.model.ts';
+import type { NoteIndexPagination } from '@/models/notes/index/noteIndexPagination.model.ts';
+export declare function useNoteBusinessIndexQuery(paginationOptions: ComputedRef<PaginationOptions<NoteIndexPagination>>, businessUuid: ComputedRef<BusinessUuid>): UseInfiniteQueryReturnType<NoteIndex>;

package/dist/api/queries/noteIndividualIndex.query.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationOptions } from '@wisemen/vue-core-components';
+import type { UseInfiniteQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model';
+import type { NoteIndex } from '@/models/notes/index/noteIndex.model.ts';
+import type { NoteIndexPagination } from '@/models/notes/index/noteIndexPagination.model.ts';
+export declare function useNoteIndividualIndexQuery(paginationOptions: ComputedRef<PaginationOptions<NoteIndexPagination>>, individualUuid: ComputedRef<IndividualUuid>): UseInfiniteQueryReturnType<NoteIndex>;

package/dist/api/queries/recentEntities.query.d.ts

@@ -0,0 +1,6 @@
+import type { PaginatedData, PaginationOptions } from '@wisemen/vue-core-components';
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { RecentEntitiesItem } from '@/models/recent-entities/recentEntitiesItem.model';
+import type { RecentEntitiesPagination } from '@/models/recent-entities/recentEntitiesPagination.model';
+export declare function useRecentEntitiesQuery(paginationOptions: ComputedRef<PaginationOptions<RecentEntitiesPagination>>): UseQueryReturnType<PaginatedData<RecentEntitiesItem>>;

package/dist/api/queries/searchIndividualIndex.query.d.ts

@@ -0,0 +1,5 @@
+import type { PaginatedData } from '@wisemen/vue-core-components';
+import type { UseQueryReturnType } from '@wisemen/vue-core-query';
+import type { ComputedRef } from 'vue';
+import type { IndividualIndex } from '@/models/individual/index/individualIndex.model.ts';
+export declare function useSearchIndividualIndexQuery(searchTerm: ComputedRef<string | null>): UseQueryReturnType<PaginatedData<IndividualIndex>>;

package/dist/api/services/board.service.d.ts

@@ -0,0 +1,4 @@
+import type { BoardColumn } from '@/models/board/boardColumn.model.ts';
+export declare class BoardService {
+    static getAllColumns(): Promise<BoardColumn[]>;
+}

package/dist/api/services/business.service.d.ts

@@ -0,0 +1,33 @@
+import type { PaginatedData, PaginationOptions } from '@wisemen/vue-core-components';
+import type { ActivityIndex } from '@/models/activity/activityIndex.model.ts';
+import type { ActivityIndexPagination } from '@/models/activity/activityIndexPagination.model.ts';
+import type { BusinessBillingInformation } from '@/models/business/billing-information/businessBillingInformation.model';
+import type { BusinessBillingInformationForm } from '@/models/business/billing-information/update/businessBillingInformationForm.model';
+import type { BusinessUuid } from '@/models/business/businessUuid.model.ts';
+import type { BusinessContactPersonDetail } from '@/models/business/contact-person/businessContactPersonDetail.model.ts';
+import type { BusinessCreateForm } from '@/models/business/create/businessCreateForm.model.ts';
+import type { BusinessDetail } from '@/models/business/detail/businessDetail.model.ts';
+import type { BusinessIndex } from '@/models/business/index/businessIndex.model.ts';
+import type { BusinessIndexPagination } from '@/models/business/index/businessIndexPagination.model.ts';
+import type { BusinessStatistics } from '@/models/business/statistics/businessStatistics.model.ts';
+import type { BusinessUpdateForm } from '@/models/business/update/businessUpdateForm.model.ts';
+import type { ContactInfo } from '@/models/contact-info/contactInfo.model.ts';
+import type { ContactPersonUpdateForm } from '@/models/contact-person/update/contactPersonUpdateForm.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+export declare class BusinessService {
+    static addChildBusiness(parentUuid: BusinessUuid, childUuid: BusinessUuid): Promise<void>;
+    static create(form: BusinessCreateForm): Promise<BusinessUuid>;
+    static findByName(name: string): Promise<PaginatedData<BusinessIndex>>;
+    static getActivity(businessUuid: BusinessUuid, paginationOptions: PaginationOptions<ActivityIndexPagination>): Promise<PaginatedData<ActivityIndex>>;
+    static getAll(paginationOptions: PaginationOptions<BusinessIndexPagination>): Promise<PaginatedData<BusinessIndex>>;
+    static getBillingInformation(uuid: BusinessUuid): Promise<BusinessBillingInformation>;
+    static getByUuid(uuid: BusinessUuid): Promise<BusinessDetail>;
+    static getContactPerson(businessUuid: BusinessUuid, contactPersonUuid: IndividualUuid): Promise<BusinessContactPersonDetail>;
+    static getStatistics(): Promise<BusinessStatistics>;
+    static linkContactPerson(businessUuid: BusinessUuid, contactPersonUuid: IndividualUuid, position: string | null, contactInfo: ContactInfo): Promise<void>;
+    static setPrimaryContactPersonForBusiness(businessUuid: BusinessUuid, contactPersonUuid: IndividualUuid): Promise<void>;
+    static unlinkContactPerson(businessUuid: BusinessUuid, contactPersonUuid: IndividualUuid): Promise<void>;
+    static update(uuid: BusinessUuid, form: BusinessUpdateForm): Promise<void>;
+    static updateContactPerson(businessUuid: BusinessUuid, contactPersonUuid: IndividualUuid, form: ContactPersonUpdateForm): Promise<void>;
+    static upsertBillingInformation(businessUuid: BusinessUuid, form: BusinessBillingInformationForm): Promise<void>;
+}

package/dist/api/services/cbe.service.d.ts

@@ -0,0 +1,5 @@
+import type { PaginatedData } from '@wisemen/vue-core-components';
+import type { CbeEnterpriseSearch } from '@/models/cbe/search/cbeEnterpriseSearch.model';
+export declare class CbeService {
+    static searchEnterprisesByTerm(searchTerm: string): Promise<PaginatedData<CbeEnterpriseSearch>>;
+}

package/dist/api/services/customFieldDefinition.service.d.ts

@@ -0,0 +1,5 @@
+import type { CustomFieldDefinitionIndex } from '@/models/custom-field-definition/customFieldDefinitionIndex.model.ts';
+import type { EntityType } from '@/models/enitityType.model.ts';
+export declare class CustomFieldDefinitionService {
+    static get(entityType: EntityType): Promise<CustomFieldDefinitionIndex[]>;
+}

package/dist/api/services/deal.service.d.ts

@@ -0,0 +1,22 @@
+import type { PaginatedData } from '@wisemen/vue-core-components';
+import type { ContactInfo } from '@/models/contact-info/contactInfo.model.ts';
+import type { ContactPersonUpdateForm } from '@/models/contact-person/update/contactPersonUpdateForm.model.ts';
+import type { DealContactPersonDetail } from '@/models/deal/contact-person/dealContactPersonDetail.model.ts';
+import type { DealCreateForm } from '@/models/deal/create/dealCreateForm.model.ts';
+import type { DealUuid } from '@/models/deal/dealUuid.model.ts';
+import type { DealDetail } from '@/models/deal/detail/dealDetail.model.ts';
+import type { DealIndex } from '@/models/deal/index/dealIndex.model.ts';
+import type { DealIndexQueryParams } from '@/models/deal/index/dealIndexQueryParams.model';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+import type { OffsetPagination, OffsetPaginationResponse } from '@/types/pagination.type';
+export declare class DealService {
+    static create(form: DealCreateForm): Promise<DealUuid>;
+    static getAll(params: OffsetPagination<DealIndexQueryParams>): Promise<OffsetPaginationResponse<DealIndex>>;
+    static getBySearchTerm(searchTerm: string): Promise<PaginatedData<DealIndex>>;
+    static getByUuid(uuid: DealUuid): Promise<DealDetail>;
+    static getContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid): Promise<DealContactPersonDetail>;
+    static linkContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid, contactInfo: ContactInfo): Promise<void>;
+    static setPrimaryContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid): Promise<void>;
+    static unlinkContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid): Promise<void>;
+    static updateContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid, form: ContactPersonUpdateForm): Promise<void>;
+}

package/dist/api/services/globalSearch.service.d.ts

@@ -0,0 +1,5 @@
+import type { GlobalSearchCollectionName } from '@/client';
+import type { GlobalSearchItem } from '@/models/global-search/globalSearchItem.model';
+export declare class GlobalSearchService {
+    static findWithSearch(search: string, collections?: GlobalSearchCollectionName[]): Promise<GlobalSearchItem[]>;
+}

package/dist/api/services/individual.service.d.ts

@@ -0,0 +1,33 @@
+import type { PaginatedData, PaginationOptions } from '@wisemen/vue-core-components';
+import type { CreateUserIndividualGrantCommand } from '@/client';
+import type { ActivityIndex } from '@/models/activity/activityIndex.model.ts';
+import type { ActivityIndexPagination } from '@/models/activity/activityIndexPagination.model.ts';
+import type { ContactInfo } from '@/models/contact-info/contactInfo.model.ts';
+import type { ContactPersonUpdateForm } from '@/models/contact-person/update/contactPersonUpdateForm.model.ts';
+import type { IndividualBillingInformation } from '@/models/individual/billing-information/individualBillingInformation.model';
+import type { IndividualBillingInformationForm } from '@/models/individual/billing-information/update/individualBillingInformationForm.model';
+import type { IndividualContactPersonDetail } from '@/models/individual/contact-person/individualContactPersonDetail.model.ts';
+import type { IndividualCreateForm } from '@/models/individual/create/individualCreateForm.model.ts';
+import type { IndividualDetail } from '@/models/individual/detail/individualDetail.model.ts';
+import type { IndividualIndex } from '@/models/individual/index/individualIndex.model.ts';
+import type { IndividualIndexPagination } from '@/models/individual/index/individualIndexPagination.model.ts';
+import type { IndividualUuid } from '@/models/individual/individualUuid.model.ts';
+import type { IndividualStatistics } from '@/models/individual/statistics/individualStatistics.model.ts';
+import type { IndividualUpdateForm } from '@/models/individual/update/individualUpdateForm.model.ts';
+export declare class IndividualService {
+    static create(form: IndividualCreateForm): Promise<IndividualUuid>;
+    static getActivity(individualUuid: IndividualUuid, paginationOptions: PaginationOptions<ActivityIndexPagination>): Promise<PaginatedData<ActivityIndex>>;
+    static getAll(paginationOptions: PaginationOptions<IndividualIndexPagination>): Promise<PaginatedData<IndividualIndex>>;
+    static getBillingInformation(individualUuid: IndividualUuid): Promise<IndividualBillingInformation>;
+    static getBySearchTerm(searchTerm: string): Promise<PaginatedData<IndividualIndex>>;
+    static getByUuid(uuid: IndividualUuid): Promise<IndividualDetail>;
+    static getContactPerson(individualUuid: IndividualUuid, contactPersonUuid: IndividualUuid): Promise<IndividualContactPersonDetail>;
+    static getStatistics(): Promise<IndividualStatistics>;
+    static grantUser(individualUuid: IndividualUuid, body: CreateUserIndividualGrantCommand): Promise<void>;
+    static linkContactPerson(individualUuid: IndividualUuid, contactPersonUuid: IndividualUuid, position: string | null, contactInfo: ContactInfo): Promise<void>;
+    static setPrimaryContactPerson(individualUuid: IndividualUuid, contactPersonUuid: IndividualUuid): Promise<void>;
+    static unlinkContactPerson(individualUuid: IndividualUuid, contactPersonUuid: IndividualUuid): Promise<void>;
+    static update(uuid: IndividualUuid, form: IndividualUpdateForm): Promise<void>;
+    static updateContactPerson(individualUuid: IndividualUuid, contactPersonUuid: IndividualUuid, form: ContactPersonUpdateForm): Promise<void>;
+    static upsertBillingInformation(individualUuid: IndividualUuid, form: IndividualBillingInformationForm): Promise<void>;
+}