@wisemen/wise-crm 0.0.0-alpha.3 → 0.0.0-alpha.4

package/dist/components/app/dialog/AppDialogPaddingContainer.vue.d.ts

@@ -0,0 +1,12 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/app/dialog/AppDialogStepper.vue.d.ts

@@ -0,0 +1,20 @@
+import type { Form } from 'formango';
+import type { z } from 'zod';
+import type { StepperForm } from '@/composables/stepper/stepper.composable.ts';
+declare const _default: <TForm extends z.ZodSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        isLoading?: boolean;
+        form: Form<TForm>;
+        stepper: StepperForm;
+    } & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/components/app/group/AppGroup.vue.d.ts

@@ -9,8 +9,8 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    align: "center" | "end" | "start" | "stretch";
     direction: "col" | "row";
+    align: "center" | "end" | "start" | "stretch";
     gap: "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | "7xl" | "8xl" | "9xl" | "10xl" | "11xl" | "lg" | "md" | "none" | "sm" | "xl" | "xs" | "xxs";
     justify: "between" | "center" | "end" | "start";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/cbe/CbeAutocomplete.vue.d.ts

@@ -0,0 +1,16 @@
+import type { CbeEnterpriseSearch } from '@/models/cbe/search/cbeEnterpriseSearch.model';
+type __VLS_Props = {
+    isRequired?: boolean;
+    label: string;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue: CbeEnterpriseSearch | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: CbeEnterpriseSearch | null) => any;
+    createNew: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: CbeEnterpriseSearch | null) => any) | undefined;
+    onCreateNew?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/entity-autocomplete/EntityAutocomplete.vue.d.ts

@@ -0,0 +1,42 @@
+declare const _default: <TValue extends string, TOptions extends {
+    uuid: TValue;
+}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onSearch?: ((args_0: string | null) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: {
+            label: string;
+            value: TValue;
+        } | null) => any) | undefined;
+        readonly onCreateNew?: (() => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onSearch" | "onCreateNew"> & ({
+        isLoading: boolean;
+        isRequired?: boolean;
+        displayFn: (uuid: TValue) => string;
+        label: string;
+        options: TOptions[];
+        placeholder: string;
+    } & {
+        modelValue: {
+            label: string;
+            value: TValue;
+        } | null;
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        option?: (props: {
+            option: TOptions;
+            isHighlighted: boolean;
+        }) => any;
+    };
+    emit: (((evt: "search", args_0: string | null) => void) & ((evt: "createNew") => void)) & ((evt: "update:modelValue", value: {
+        label: string;
+        value: TValue;
+    } | null) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/components/info-dialog/InfoDialogHeaderCard.vue.d.ts

@@ -7,5 +7,15 @@ type __VLS_Props = {
     mobilePhone: string | null;
     phone: string | null;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/composables/keyset-infinite-query/keysetInfiniteQuery.composable.d.ts

@@ -0,0 +1,234 @@
+import type { QueryKeys } from '@wisemen/vue-core-query';
+import type { MaybeRef } from 'vue';
+import type { KeysetPaginationParams, KeysetPaginationResponse } from '@/types/pagination.type';
+type NonOptionalKeys<T> = {
+    [K in keyof T]-?: T[K];
+};
+interface Options<TData> {
+    staleTime?: number;
+    limit?: number;
+    queryFn: (paginationParams: KeysetPaginationParams) => Promise<KeysetPaginationResponse<TData>>;
+    queryKey: {
+        [TQueryKey in keyof QueryKeys]?: {
+            [TQueryKeyParam in keyof NonOptionalKeys<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]>;
+        };
+    };
+}
+export declare function useKeysetInfiniteQuery<TData>(options: Options<TData>): {
+    data: import("vue").ComputedRef<KeysetPaginationResponse<TData>>;
+    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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<KeysetPaginationResponse<TData>>;
+    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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<KeysetPaginationResponse<TData>>;
+    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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<KeysetPaginationResponse<TData>>;
+    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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<KeysetPaginationResponse<TData>>;
+    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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<KeysetPaginationResponse<TData>>;
+    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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, 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<KeysetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<KeysetPaginationResponse<TData>, unknown>, Error>>;
+};
+export {};

package/dist/composables/offset-infinite-query/offsetInfiniteQuery.composable.d.ts

@@ -0,0 +1,234 @@
+import type { QueryKeys } from '@wisemen/vue-core-query';
+import type { MaybeRef } from 'vue';
+import type { OffsetPaginationParams, OffsetPaginationResponse } from '@/types/pagination.type';
+type NonOptionalKeys<T> = {
+    [K in keyof T]-?: T[K];
+};
+interface Options<TData> {
+    staleTime?: number;
+    limit?: number;
+    queryFn: (paginationParams: OffsetPaginationParams) => Promise<OffsetPaginationResponse<TData>>;
+    queryKey: {
+        [TQueryKey in keyof QueryKeys]?: {
+            [TQueryKeyParam in keyof NonOptionalKeys<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]>;
+        };
+    };
+}
+export declare function useOffsetInfiniteQuery<TData>(options: Options<TData>): {
+    data: import("vue").ComputedRef<OffsetPaginationResponse<TData>>;
+    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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<OffsetPaginationResponse<TData>>;
+    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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<OffsetPaginationResponse<TData>>;
+    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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<OffsetPaginationResponse<TData>>;
+    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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<OffsetPaginationResponse<TData>>;
+    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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>, Error>>;
+} | {
+    data: import("vue").ComputedRef<OffsetPaginationResponse<TData>>;
+    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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, 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<OffsetPaginationResponse<TData>, unknown>>, Promise<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>>>;
+    suspense: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverResult<import("@tanstack/vue-query").InfiniteData<OffsetPaginationResponse<TData>, unknown>, Error>>;
+};
+export {};

package/dist/composables/stepper/stepper.composable.d.ts

@@ -0,0 +1,18 @@
+import type { ComputedRef, Ref } from 'vue';
+export interface Step {
+    id: string;
+    title: string;
+    isValid: () => boolean;
+}
+export interface StepperForm {
+    findStepAt: (index: number) => Step | undefined;
+    isCurrent: (step: string) => boolean;
+    isFirst: ComputedRef<boolean>;
+    isLast: ComputedRef<boolean>;
+    current: ComputedRef<Step>;
+    goToNext: () => void;
+    goToPrevious: () => void;
+    index: Ref<number>;
+    steps: ComputedRef<Record<string, Step>>;
+}
+export declare function useFormStepper(steps: ComputedRef<Step[]>): StepperForm;

package/dist/deal/components/DealCreateDialog.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;