startx 1.0.1 → 1.0.3

package/packages/ui/components.json

@@ -1,16 +1,23 @@
 {
 	"$schema": "https://ui.shadcn.com/schema.json",
-	"style": "default",
-	"rsc": true,
+	"style": "radix-sera",
+	"rsc": false,
 	"tsx": true,
 	"tailwind": {
-		"config": "tailwind.config.ts",
-		"css": "src/globals.css",
-		"baseColor": "zinc",
+		"config": "",
+		"css": "src/styles/globals.css",
+		"baseColor": "neutral",
 		"cssVariables": true
 	},
+	"iconLibrary": "phosphor",
 	"aliases": {
-		"components": "@/components",
-		"utils": "@/lib/utils"
-	}
+		"components": "@repo/ui/components",
+		"utils": "@repo/ui/lib/utils",
+		"hooks": "@repo/ui/hooks",
+		"lib": "@repo/ui/lib",
+		"ui": "@repo/ui/components"
+	},
+	"rtl": false,
+	"menuColor": "inverted-translucent",
+	"menuAccent": "subtle"
 }

package/packages/ui/package.json

@@ -1,69 +1,59 @@
 {
-	"name": "ui",
+	"name": "@repo/ui",
 	"version": "0.0.0",
 	"private": true,
 	"type": "module",
 	"scripts": {
 		"clean": "rimraf dist .turbo",
-		"watch:dev": "pnpm watch",
 		"typecheck": "tsc --noEmit",
 		"format": "biome format --write .",
 		"format:check": "biome ci .",
 		"test": "vitest run",
 		"lint": "eslint .",
-		"lint:fix": "eslint . --fix",
-		"watch": "tsc -p tsconfig.build.json --watch"
+		"lint:fix": "eslint . --fix"
 	},
 	"peerDependencies": {
 		"react": "^19.0.0"
 	},
 	"devDependencies": {
-		"@types/node": "catalog:",
+		"@tailwindcss/vite": "catalog:",
 		"@types/react": "catalog:",
+		"@types/react-dom": "catalog:",
 		"autoprefixer": "^10",
 		"eslint-config": "workspace:*",
-		"postcss": "^8.4.49",
-		"postcss-load-config": "^6",
 		"tailwindcss": "catalog:",
 		"typescript-config": "workspace:*",
 		"vitest-config": "workspace:*"
 	},
 	"dependencies": {
+		"@fontsource-variable/eb-garamond": "^5.2.7",
+		"@fontsource-variable/inter": "^5.2.8",
 		"@hookform/resolvers": "^3.9.1",
-		"@radix-ui/react-alert-dialog": "^1.1.15",
-		"@radix-ui/react-avatar": "^1.1.1",
-		"@radix-ui/react-checkbox": "^1.1.2",
-		"@radix-ui/react-dialog": "^1.1.15",
-		"@radix-ui/react-dropdown-menu": "^2.1.2",
-		"@radix-ui/react-label": "^2.1.0",
-		"@radix-ui/react-popover": "^1.1.2",
-		"@radix-ui/react-select": "^2.1.2",
-		"@radix-ui/react-separator": "^1.1.0",
-		"@radix-ui/react-slot": "^1.2.3",
-		"@radix-ui/react-switch": "^1.1.1",
-		"@radix-ui/react-tabs": "^1.1.1",
-		"@radix-ui/react-tooltip": "^1.1.3",
+		"@phosphor-icons/react": "^2.1.10",
 		"@tailwindcss/postcss": "^4",
-		"class-variance-authority": "^0.7.0",
+		"class-variance-authority": "^0.7.1",
 		"clsx": "^2.1.1",
 		"cmdk": "^1.1.1",
-		"date-fns": "^4.1.0",
-		"embla-carousel": "^8.5.2",
-		"embla-carousel-react": "^8.5.2",
-		"input-otp": "^1.4.1",
+		"embla-carousel-react": "^8.6.0",
+		"input-otp": "^1.4.2",
 		"lucide-react": "catalog:",
-		"react-hook-form": "^7.53.1",
+		"next-themes": "^0.4.6",
+		"radix-ui": "^1.4.3",
+		"react-hook-form": "^7.75.0",
 		"react-icons": "^5.5.0",
-		"sonner": "^1.7.0",
+		"sonner": "^2.0.7",
 		"tailwind-merge": "^2.3.0",
-		"tailwindcss-animate": "^1.0.7"
+		"tw-animate-css": "^1.4.0",
+		"@tanstack/react-query": "catalog:",
+		"@tanstack/react-query-devtools": "catalog:"
 	},
 	"exports": {
-		"./globals.css": "./src/globals.css",
-		"./postcss.config": "./postcss.config.mjs",
-		"./lucide": "./src/lucide.ts",
-		"./tailwind.config": "./tailwind.config.ts",
-		"./*/*": "./src/components/*/*"
+		"./globals.css": "./src/styles/globals.css",
+		"./*": "./src/*.ts",
+		"./lib/*": "./src/lib/utils.ts",
+		"./components/*": "./src/components/*.tsx",
+		"./hooks/*": "./src/hooks/*.ts",
+		"./api": "./src/api/index.ts"
 	},
 	"startx": {
 		"iTags": [
@@ -72,9 +62,6 @@
 		],
 		"requiredDevDeps": [
 			"typescript-config"
-		],
-		"ignore": [
-			"vitest-config"
 		]
 	}
 }

package/packages/ui/src/api/axios/i-client.ts

@@ -0,0 +1,40 @@
+import axios, { AxiosError, type AxiosInstance } from "axios";
+
+type IAxiosClientOpts = {
+	includeDefaultInterceptors?: boolean;
+};
+
+export abstract class IAxiosClient {
+	public readonly privateClient: AxiosInstance;
+	public readonly publicClient: AxiosInstance;
+	protected accessToken: string | null = null;
+	protected opts: IAxiosClientOpts;
+	constructor(baseURL: string, opts: IAxiosClientOpts) {
+		this.publicClient = axios.create({ baseURL });
+
+		this.privateClient = axios.create({
+			baseURL,
+			withCredentials: true,
+		});
+		this.opts = opts;
+
+		this.defaultInterceptors();
+		this.setupInterceptors();
+	}
+
+	protected defaultInterceptors(): void {
+		if (!this.opts.includeDefaultInterceptors) return;
+		this.privateClient.interceptors.request.use(
+			config => {
+				if (this.accessToken) {
+					config.headers.Authorization = `Bearer ${this.accessToken}`;
+				}
+				return config;
+			},
+			(error: AxiosError) => Promise.reject(error)
+		);
+	}
+
+	abstract setupInterceptors(): void;
+	abstract getAccessToken(): Promise<string>;
+}

package/packages/ui/src/api/index.ts

@@ -0,0 +1,6 @@
+import { QueryProvider } from "./query-provider";
+import { ApiSchema } from "./use-api/api-builder";
+import { useApi } from "./use-api/react-query/use-api";
+import { useApiClient } from "./use-api/react-query/use-api-client";
+
+export { QueryProvider, ApiSchema, useApi, useApiClient };

package/packages/ui/src/api/query-provider.tsx

@@ -0,0 +1,34 @@
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
+import { type ReactNode } from "react";
+import { ApiHelper } from "./use-api/api-helpers";
+
+const queryClient = new QueryClient({
+	defaultOptions: {
+		queries: {
+			refetchOnMount: false,
+			refetchOnWindowFocus: false,
+			staleTime: ApiHelper.parseTime("5:min"),
+		},
+		mutations: {
+			onError(error: any) {
+				console.error(error?.response?.data);
+				// toast.error(error.response?.data?.message ?? error.message);
+			},
+		},
+	},
+});
+export const QueryProvider = ({
+	children,
+	mode,
+}: {
+	children: ReactNode;
+	mode?: "development" | "production" | "staging";
+}) => {
+	return (
+		<QueryClientProvider client={queryClient}>
+			{mode === "development" && <ReactQueryDevtools initialIsOpen={false} />}
+			{children}
+		</QueryClientProvider>
+	);
+};

package/packages/ui/src/api/use-api/api-builder.ts

@@ -0,0 +1,139 @@
+import type { AxiosError, AxiosInstance } from "axios";
+import { z, ZodTypeAny } from "zod";
+import type {
+	IFetchOptions,
+	IPaginatedFetchOptions,
+	IFetchMutationOptions,
+	IRefetch,
+	QueryEvent,
+	IPaginatedData,
+	RawSchema,
+	RawSchemaKeys,
+	CbAction,
+	QueryEventWithKeys,
+	QueryKey,
+	ZQuery,
+	ZParams,
+} from "./api-types";
+import { makeQueryKeyFactory, createQueryKeysProxy, type QueryKeyFactory } from "./query-factory";
+import { useApi } from "./react-query/use-api";
+
+type EnsureUnique<Key extends string, ExistingKeys extends string> = Key extends ExistingKeys
+	? `❌ Api key '${Key}' already exists.`
+	: Key;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export class ApiSchema<Schema extends RawSchema = {}> {
+	readonly schema: Schema;
+
+	constructor(schema?: Schema) {
+		this.schema = schema ?? ({} as Schema);
+	}
+
+	private wrapRefetch<IK extends string, IQ extends z.output<ZQuery>, IP extends z.output<ZParams>, IB, ID>(
+		refetch: IRefetch<IK, IQ, IP, IB, ID, Schema> | undefined
+	): IRefetch<IK, IQ, IP, IB, ID> | undefined {
+		if (!refetch) return undefined;
+		const { cb, ...rest } = refetch;
+		return {
+			...rest,
+			cb: props => (typeof cb === "function" ? cb(props, createQueryKeysProxy(this.schema)) : cb),
+		};
+	}
+
+	private wrapQueryEvent<IK extends string, IQ extends z.output<ZQuery>, IP extends z.output<ZParams>, IB, ID>(
+		event: QueryEventWithKeys<IK, IQ, IP, IB, ID, Schema> | undefined
+	): QueryEvent<IK, IQ, IP, IB, ID> | undefined {
+		if (!event) return undefined;
+		const wrapped: QueryEvent<IK, IQ, IP, IB, ID> = {};
+		const wrapCb = (cb: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<string>>>) =>
+			typeof cb === "function" ? (props: Parameters<typeof cb>[0]) => cb(props, createQueryKeysProxy(this.schema)) : cb;
+		if (event.fn) wrapped.fn = event.fn;
+		if (event.invalidateQuery) wrapped.invalidateQuery = wrapCb(event.invalidateQuery);
+		if (event.refetchQuery) wrapped.refetchQuery = wrapCb(event.refetchQuery);
+		if (event.clearQuery) wrapped.clearQuery = wrapCb(event.clearQuery);
+		return wrapped;
+	}
+
+	fetch<KEY extends string, ZQ extends ZQuery, ZP extends ZParams, ID = unknown>(
+		key: EnsureUnique<KEY, RawSchemaKeys<Schema>>,
+		options: Omit<IFetchOptions<ID, ZQ, ZP, string>, "apiType" | "refetch"> & {
+			refetch?: IRefetch<KEY | RawSchemaKeys<Schema>, z.output<ZQ>, z.output<ZP>, undefined, ID, Schema>;
+		}
+	): ApiSchema<Schema & Record<KEY, IFetchOptions<ID, ZQ, ZP, KEY> & { queryKey: QueryKeyFactory<ZQ, ZP> }>> {
+		const { refetch, ...rest } = options;
+		const entry = {
+			...rest,
+			apiType: "fetch" as const,
+			queryKey: makeQueryKeyFactory(options.key ?? [], options.zParams, options.zQuery),
+			refetch: this.wrapRefetch(refetch),
+		};
+		return new ApiSchema({ ...this.schema, [key]: entry });
+	}
+
+	paginatedFetch<KEY extends string, ID, IO, ZQ extends ZQuery, ZP extends ZParams>(
+		key: EnsureUnique<KEY, RawSchemaKeys<Schema>>,
+		options: Omit<IPaginatedFetchOptions<ID, IO, ZQ, ZP, string>, "apiType" | "refetch"> & {
+			refetch?: IRefetch<
+				KEY | RawSchemaKeys<Schema>,
+				z.output<ZQ>,
+				z.output<ZP>,
+				undefined,
+				IPaginatedData<ID, IO>,
+				Schema
+			>;
+		}
+	): ApiSchema<
+		Schema & Record<KEY, IPaginatedFetchOptions<ID, IO, ZQ, ZP, KEY> & { queryKey: QueryKeyFactory<ZQ, ZP> }>
+	> {
+		const { refetch, ...rest } = options;
+		const entry = {
+			...rest,
+			apiType: "paginated-fetch" as const,
+			queryKey: makeQueryKeyFactory(options.key ?? [], options.zParams, options.zQuery),
+			refetch: this.wrapRefetch(refetch),
+		};
+		return new ApiSchema({ ...this.schema, [key]: entry });
+	}
+
+	mutation<KEY extends string, ZQ extends ZQuery, ZB extends ZodTypeAny, ZP extends ZParams, ID = unknown>(
+		key: EnsureUnique<KEY, RawSchemaKeys<Schema>>,
+		options: Omit<
+			IFetchMutationOptions<KEY | RawSchemaKeys<Schema>, ZQ, ZB, ZP, ID>,
+			"apiType" | "onSuccess" | "onFetch" | "onError" | "refetch"
+		> & {
+			onSuccess?: QueryEventWithKeys<KEY | RawSchemaKeys<Schema>, z.output<ZQ>, z.output<ZP>, z.output<ZB>, ID, Schema>;
+			onFetch?: QueryEventWithKeys<KEY | RawSchemaKeys<Schema>, z.output<ZQ>, z.output<ZP>, z.output<ZB>, ID, Schema>;
+			onError?: QueryEventWithKeys<
+				KEY | RawSchemaKeys<Schema>,
+				z.output<ZQ>,
+				z.output<ZP>,
+				z.output<ZB>,
+				AxiosError<{ message?: string }>,
+				Schema
+			>;
+			refetch?: IRefetch<KEY | RawSchemaKeys<Schema>, z.output<ZQ>, z.output<ZP>, z.output<ZB>, ID, Schema>;
+		}
+	): ApiSchema<
+		Schema & Record<KEY, IFetchMutationOptions<KEY, ZQ, ZB, ZP, ID> & { queryKey: QueryKeyFactory<ZQ, ZP> }>
+	> {
+		const { onSuccess, onFetch, onError, refetch, ...rest } = options;
+		const entry = {
+			...rest,
+			apiType: "mutation" as const,
+			queryKey: makeQueryKeyFactory([], options.zParams, options.zQuery),
+			onSuccess: this.wrapQueryEvent(onSuccess),
+			onFetch: this.wrapQueryEvent(onFetch),
+			onError: this.wrapQueryEvent(onError),
+			refetch: this.wrapRefetch(refetch),
+		};
+		return new ApiSchema({ ...this.schema, [key]: entry });
+	}
+
+	getSchema(): Schema {
+		return this.schema;
+	}
+	getReactQuery(axios: AxiosInstance) {
+		return useApi(this.schema, axios);
+	}
+}

package/packages/ui/src/api/use-api/api-helpers.ts

@@ -0,0 +1,165 @@
+import { ZodTypeAny, z } from "zod";
+import type { QueryKey, TimeString, TimeUnit, ZParams, ZQuery } from "./api-types";
+
+type AnyObject = Record<PropertyKey, unknown>;
+
+type DeepMerge<A, B> = A extends AnyObject
+	? B extends AnyObject
+		? {
+				[K in keyof A | keyof B]: K extends keyof A
+					? K extends keyof B
+						? DeepMerge<A[K], B[K]>
+						: A[K]
+					: K extends keyof B
+						? B[K]
+						: never;
+			}
+		: A | B
+	: A | B;
+
+export class ApiHelper {
+	static parseTime(input?: TimeString | number): number | undefined {
+		if (input === undefined || input === null) return undefined;
+		if (typeof input === "number") return input;
+
+		const [numStr, unit] = input.split(":") as [string, TimeUnit];
+		const value = Number(numStr);
+		if (isNaN(value)) return undefined;
+
+		switch (unit) {
+			case "ms":
+				return value;
+			case "sec":
+				return value * 1000;
+			case "min":
+				return value * 1000 * 60;
+			case "hour":
+				return value * 1000 * 60 * 60;
+			default:
+				return 0;
+		}
+	}
+
+	static validateSchema(schema: ZodTypeAny, value: unknown) {
+		const result = schema.safeParse(value);
+		if (result.success) return { success: true as const, data: result.data };
+
+		return {
+			success: false as const,
+			errors: result.error.issues.map(i => `${i.path.join(".")}: ${i.message}`),
+		};
+	}
+
+	static buildUrl<ZP extends ZParams = ZParams, ZQ extends ZQuery = ZQuery>({
+		route,
+		params,
+		searchParams,
+	}: {
+		route: string;
+		params?: z.output<ZP>;
+		searchParams?: z.output<ZQ>;
+	}): string {
+		let url = route;
+
+		if (params) {
+			for (const [key, value] of Object.entries(params)) {
+				if (value === undefined || value === null) continue;
+
+				url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+			}
+		}
+
+		if (searchParams) {
+			const search = new URLSearchParams();
+
+			const sortedKeys = Object.keys(searchParams).sort();
+
+			for (const key of sortedKeys) {
+				const value = searchParams[key];
+
+				if (value === undefined || value === null) continue;
+
+				if (Array.isArray(value)) {
+					for (const item of value) {
+						search.append(key, String(item));
+					}
+				} else {
+					search.set(key, String(value));
+				}
+			}
+
+			const qs = search.toString();
+			if (qs) {
+				url += `?${qs}`;
+			}
+		}
+
+		return url;
+	}
+	static getQueryKey<IK extends string, ZQ extends ZQuery = ZQuery, ZP extends ZParams = ZParams>(
+		key: IK,
+		extraKey?: string[],
+		input?: {
+			query?: z.output<ZQ>;
+			params?: z.output<ZP>;
+		}
+	): QueryKey<IK> {
+		const keys: string[] = [key];
+
+		const append = (prefix: "query" | "params", obj?: z.output<ZQ | ZP>) => {
+			if (!obj) return;
+			const sortedKeys = Object.keys(obj).sort();
+			for (const k of sortedKeys) {
+				const v = obj[k];
+				if (v === undefined) continue;
+				if (Array.isArray(v)) {
+					for (const item of v) {
+						keys.push(`${prefix}:${k}:${item}`);
+					}
+				} else {
+					keys.push(`${prefix}:${k}:${v}`);
+				}
+			}
+		};
+
+		append("params", input?.params);
+		append("query", input?.query);
+
+		if (extraKey?.length) {
+			keys.push(...extraKey.filter(Boolean));
+		}
+
+		return keys as QueryKey<IK>;
+	}
+
+	private static isPlainObject(value: unknown): value is AnyObject {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	}
+
+	private static isEmpty(value: unknown): boolean {
+		if (value == null) return true;
+		if (typeof value === "string") return value.length === 0;
+		if (Array.isArray(value)) return value.length === 0;
+		if (ApiHelper.isPlainObject(value)) return Object.keys(value).length === 0;
+		return false;
+	}
+
+	static merge<A, B>(first: A, second: B): DeepMerge<A, B> {
+		if (ApiHelper.isEmpty(first)) return second as DeepMerge<A, B>;
+		if (ApiHelper.isEmpty(second)) return first as DeepMerge<A, B>;
+
+		if (ApiHelper.isPlainObject(first) && ApiHelper.isPlainObject(second)) {
+			const out: AnyObject = { ...second, ...first };
+
+			for (const key of Object.keys(second)) {
+				if (key in first) {
+					out[key] = ApiHelper.merge((first as AnyObject)[key], (second as AnyObject)[key]);
+				}
+			}
+
+			return out as DeepMerge<A, B>;
+		}
+
+		return first as DeepMerge<A, B>;
+	}
+}

package/packages/ui/src/api/use-api/api-types.ts

@@ -0,0 +1,138 @@
+import type { AxiosError } from "axios";
+import { z, ZodTypeAny, type ZodObject, type ZodType } from "zod";
+
+export type ApiType = "fetch" | "mutation" | "paginated-fetch";
+export type ApiMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+
+export type TimeUnit = "ms" | "sec" | "min" | "hour";
+export type TimeString = `${number}:${TimeUnit}`;
+
+export type AutoSuggest<T extends string> = T | (string & {});
+export type QueryKey<K extends string> = [AutoSuggest<K>, ...string[]];
+
+export type RawSchema = Record<string, any>;
+export type RawSchemaKeys<Schema extends RawSchema> = Extract<keyof Schema, string>;
+
+export type SchemaQueryKeys<Schema extends RawSchema> = {
+	[K in keyof Schema & string]: Schema[K] extends { queryKey: (...args: any[]) => any } ? Schema[K]["queryKey"] : never;
+};
+
+export type ValidParamValue = string | number | boolean | null | undefined;
+export type ValidQueryValue = ValidParamValue | ValidParamValue[];
+export type ZParams = ZodObject<Record<string, ZodType<ValidParamValue>>>;
+export type ZQuery = ZodObject<Record<string, ZodType<ValidQueryValue>>>;
+
+export interface IBaseApi<ID, ZQ extends ZQuery, ZP extends ZParams> {
+	apiType: ApiType;
+	route: string;
+	method?: ApiMethod;
+	zQuery?: ZQ;
+	zParams?: ZP;
+	data?: ID;
+	retry?: { count: number; interval: number };
+}
+
+export type CbAction<
+	Schema extends RawSchema,
+	IP extends z.output<ZParams>,
+	IQ extends z.output<ZQuery>,
+	IB,
+	ID,
+	IK extends string,
+	CB,
+> = NoInfer<
+	| Array<QueryKey<IK>>
+	| ((props: { query?: IQ; params?: IP; body?: IB; data?: ID }, queryKeys?: SchemaQueryKeys<Schema>) => CB)
+>;
+
+export type QueryEvent<
+	IK extends string,
+	IQ extends z.output<ZQuery>,
+	IP extends z.output<ZParams>,
+	IB,
+	ID,
+	Schema extends RawSchema = RawSchema,
+> = {
+	fn?: CbAction<Schema, IP, IQ, IB, ID, IK, Promise<void>>;
+	invalidateQuery?: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+	refetchQuery?: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+	clearQuery?: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+};
+
+export type QueryEventWithKeys<
+	IK extends string,
+	IQ extends z.output<ZQuery>,
+	IP extends z.output<ZParams>,
+	IB,
+	ID,
+	Schema extends RawSchema,
+> = {
+	fn?: (props: { query?: IQ; params?: IP; body?: IB; data?: ID }) => Promise<void>;
+	invalidateQuery?: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+	refetchQuery?: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+	clearQuery?: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+};
+
+export type IRefetch<
+	IK extends string,
+	IQ extends z.output<ZQuery>,
+	IP extends z.output<ZParams>,
+	IB,
+	ID,
+	Schema extends RawSchema = RawSchema,
+> = {
+	count?: number;
+	delay?: number;
+	onMount?: boolean;
+	onFocus?: boolean;
+	interval?: { ms: number; inBackground?: boolean };
+	cb: CbAction<Schema, IP, IQ, IB, ID, IK, Array<QueryKey<IK>>>;
+};
+
+export interface IFetchOptions<ID, ZQ extends ZQuery = ZQuery, ZP extends ZParams = ZParams, IK extends string = string>
+	extends IBaseApi<ID, ZQ, ZP> {
+	apiType: "fetch";
+	staleTime?: TimeString | number;
+	enable?: { isEnable?: boolean; autoEnable?: boolean };
+	key?: string[];
+	refetch?: IRefetch<IK, z.output<ZQ>, z.output<ZP>, undefined, ID>;
+}
+
+export type IPaginatedData<IData, IOther = unknown> = {
+	data: IData[];
+	other?: IOther;
+	pagination: { total: number; totalPages: number; currentPage: number; pageSize: number };
+};
+
+export interface IPaginatedFetchOptions<
+	ID,
+	IO,
+	ZQ extends ZQuery = ZQuery,
+	ZP extends ZParams = ZParams,
+	IK extends string = string,
+> extends IBaseApi<ID, ZQ, ZP> {
+	apiType: "paginated-fetch";
+	staleTime?: TimeString | number;
+	enable?: { isEnable?: boolean; autoEnable?: boolean };
+	other?: IO;
+	key?: string[];
+	refetch?: IRefetch<IK, z.output<ZQ>, z.output<ZP>, undefined, IPaginatedData<ID, IO>>;
+}
+
+export interface IFetchMutationOptions<
+	IK extends string,
+	ZQ extends ZQuery = ZQuery,
+	ZB extends ZodTypeAny = ZodTypeAny,
+	ZP extends ZParams = ZParams,
+	ID = unknown,
+> extends IBaseApi<ID, ZQ, ZP> {
+	apiType: "mutation";
+	isFormData?: boolean;
+	validateBody?: boolean;
+	staleTime?: TimeString | number;
+	zBody?: ZB;
+	onSuccess?: QueryEvent<IK, z.output<ZQ>, z.output<ZP>, z.output<ZB>, ID>;
+	onFetch?: QueryEvent<IK, z.output<ZQ>, z.output<ZP>, z.output<ZB>, ID>;
+	onError?: QueryEvent<IK, z.output<ZQ>, z.output<ZP>, z.output<ZB>, AxiosError<{ message?: string }>>;
+	refetch?: IRefetch<IK, z.output<ZQ>, z.output<ZP>, z.output<ZB>, ID>;
+}