@wisemen/wise-crm-web 1.3.1 → 2.0.0-alpha.0

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

@@ -1,220 +0,0 @@
-import type { RecentEntitiesIndexQueryParams } from '@/models/recent-entities/recentEntitiesIndexQueryParams';
-import type { RecentEntitiesItem } from '@/models/recent-entities/recentEntitiesItem.model';
-import type { InfiniteQueryOptions } from '@/types/query.type';
-export declare function useRecentEntitiesQuery(params?: InfiniteQueryOptions<RecentEntitiesIndexQueryParams>): {
-    data: import("vue").ComputedRef<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>>;
-    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<RecentEntitiesItem>, 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<RecentEntitiesItem>, 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<RecentEntitiesItem>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>>;
-    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<RecentEntitiesItem>, 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<RecentEntitiesItem>, 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<RecentEntitiesItem>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>>;
-    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<RecentEntitiesItem>, 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<RecentEntitiesItem>, 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<RecentEntitiesItem>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>>;
-    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<RecentEntitiesItem>, 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<RecentEntitiesItem>, 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<RecentEntitiesItem>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>>;
-    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<RecentEntitiesItem>, 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<RecentEntitiesItem>, 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<RecentEntitiesItem>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>>;
-    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<RecentEntitiesItem>, 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<RecentEntitiesItem>, 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<RecentEntitiesItem>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../types/pagination.type").OffsetPaginationResponse<RecentEntitiesItem>, unknown>, Error>>;
-};

package/dist/api/queries/user/userIndex.query.d.ts

@@ -1,220 +0,0 @@
-import type { UserIndex } from '@/models/user/index/userIndex.model';
-import type { UserIndexQueryParams } from '@/models/user/index/userIndexQueryParams.model';
-import type { InfiniteQueryOptions } from '@/types/query.type';
-export declare function useUserIndexQuery(params: InfiniteQueryOptions<UserIndexQueryParams>): {
-    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>>;
-    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<UserIndex>, 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<UserIndex>, 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<UserIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>>;
-    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<UserIndex>, 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<UserIndex>, 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<UserIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>>;
-    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<UserIndex>, 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<UserIndex>, 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<UserIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>>;
-    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<UserIndex>, 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<UserIndex>, 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<UserIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>>;
-    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<UserIndex>, 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<UserIndex>, 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<UserIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>, Error>>;
-} | {
-    data: import("vue").ComputedRef<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>>;
-    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<UserIndex>, 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<UserIndex>, 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<UserIndex>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>>>;
-    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<import("../../../types/pagination.type").OffsetPaginationResponse<UserIndex>, unknown>, Error>>;
-};

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

@@ -1,8 +0,0 @@
-import type { BoardColumnTransitionTriggerType } from '@/client';
-import type { BoardColumn } from '@/models/board/boardColumn.model.ts';
-import type { BoardColumnUuid } from '@/models/board/boardColumnUuid.model';
-import type { BoardColumnTransition } from '@/models/board/transition/boardColumnTransition.model';
-export declare class BoardService {
-    static getAllColumns(): Promise<BoardColumn[]>;
-    static getTransitions(boardColumnUuid: BoardColumnUuid, triggerTypes: BoardColumnTransitionTriggerType[]): Promise<BoardColumnTransition[]>;
-}

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

@@ -1,34 +0,0 @@
-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 { BusinessIndexQueryParams } from '@/models/business/index/businessIndexQueryParams.model';
-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';
-import type { OffsetPagination, OffsetPaginationResponse } from '@/types/pagination.type';
-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(params: OffsetPagination<BusinessIndexQueryParams>): Promise<OffsetPaginationResponse<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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,27 +0,0 @@
-import type { PaginatedData } from '@wisemen/vue-core-components';
-import type { BoardColumnUuid } from '@/models/board/boardColumnUuid.model';
-import type { ContactInfo } from '@/models/contact-info/contactInfo.model.ts';
-import type { DealContactPersonDetail } from '@/models/deal/contact-person/dealContactPersonDetail.model.ts';
-import type { DealContactPersonUpdateFormData } from '@/models/deal/contact-person/dealContactPersonUpdateForm.model';
-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 { DealUpdateForm } from '@/models/deal/update/dealUpdateForm.model.ts';
-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 createContactPerson(): Promise<void>;
-    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 transition(dealUuid: DealUuid, toBoardColumnUuid: BoardColumnUuid): Promise<void>;
-    static unlinkContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid): Promise<void>;
-    static update(uuid: DealUuid, form: DealUpdateForm): Promise<void>;
-    static updateContactPerson(dealUuid: DealUuid, contactPersonUuid: IndividualUuid, form: DealContactPersonUpdateFormData): Promise<void>;
-}

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

@@ -1,5 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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 { IndividualIndexQueryParams } from '@/models/individual/index/individualIndexQueryParams.model';
-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';
-import type { OffsetPagination, OffsetPaginationResponse } from '@/types/pagination.type';
-export declare class IndividualService {
-    static create(form: IndividualCreateForm): Promise<IndividualUuid>;
-    static getActivity(individualUuid: IndividualUuid, paginationOptions: PaginationOptions<ActivityIndexPagination>): Promise<PaginatedData<ActivityIndex>>;
-    static getAll(params: OffsetPagination<IndividualIndexQueryParams>): Promise<OffsetPaginationResponse<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>;
-}

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

@@ -1,10 +0,0 @@
-import type { PublicFileReference } from '@/models/file-reference/fileReference.model';
-import type { MailCreateForm } from '@/models/mail/create/mailCreateForm.model.ts';
-import type { MailIndex } from '@/models/mail/index/mailIndex.model.ts';
-import type { MailIndexQueryParams } from '@/models/mail/index/mailIndexQueryParams.model';
-import type { MailUuid } from '@/models/mail/mailUuid.model.ts';
-import type { OffsetPagination } from '@/types/pagination.type';
-export declare class MailService {
-    static create(form: MailCreateForm, externalAttachments: PublicFileReference[]): Promise<MailUuid>;
-    static getAll(params: OffsetPagination<MailIndexQueryParams>): Promise<MailIndex[]>;
-}