@cartanova/qgrid-cli 2.6.11 → 2.7.1

package/bundle/web-dist/server/assets/services.generated-BAGLi2r8.js

@@ -1,1313 +0,0 @@
-import { B as resolveStaleTime, C as infiniteQueryBehavior, D as notifyManager, G as timeoutManager, H as shouldThrowError, I as noop, K as focusManager, N as isValidTimeout, O as pendingThenable, R as replaceData, S as hasPreviousPage, T as fetchState, V as shallowEqualObjects, W as timeUntilStale, Z as __toESM, _ as require_jsx_runtime, a as fetch, b as getDefaultState, c as useSSEStream, g as useQueryClient, i as dedupeAndFlatten, j as hashKey, k as environmentManager, p as require_lib, q as Subscribable, s as useRefreshable, v as require_react, x as hasNextPage, z as resolveEnabled } from "./sd.generated-CuyajYtc.js";
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/queryObserver.js
-var QueryObserver = class extends Subscribable {
-	constructor(client, options) {
-		super();
-		this.options = options;
-		this.#client = client;
-		this.#selectError = null;
-		this.#currentThenable = pendingThenable();
-		this.bindMethods();
-		this.setOptions(options);
-	}
-	#client;
-	#currentQuery = void 0;
-	#currentQueryInitialState = void 0;
-	#currentResult = void 0;
-	#currentResultState;
-	#currentResultOptions;
-	#currentThenable;
-	#selectError;
-	#selectFn;
-	#selectResult;
-	#lastQueryWithDefinedData;
-	#staleTimeoutId;
-	#refetchIntervalId;
-	#currentRefetchInterval;
-	#trackedProps = /* @__PURE__ */ new Set();
-	bindMethods() {
-		this.refetch = this.refetch.bind(this);
-	}
-	onSubscribe() {
-		if (this.listeners.size === 1) {
-			this.#currentQuery.addObserver(this);
-			if (shouldFetchOnMount(this.#currentQuery, this.options)) this.#executeFetch();
-			else this.updateResult();
-			this.#updateTimers();
-		}
-	}
-	onUnsubscribe() {
-		if (!this.hasListeners()) this.destroy();
-	}
-	shouldFetchOnReconnect() {
-		return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
-	}
-	shouldFetchOnWindowFocus() {
-		return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
-	}
-	destroy() {
-		this.listeners = /* @__PURE__ */ new Set();
-		this.#clearStaleTimeout();
-		this.#clearRefetchInterval();
-		this.#currentQuery.removeObserver(this);
-	}
-	setOptions(options) {
-		const prevOptions = this.options;
-		const prevQuery = this.#currentQuery;
-		this.options = this.#client.defaultQueryOptions(options);
-		if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
-		this.#updateQuery();
-		this.#currentQuery.setOptions(this.options);
-		if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) this.#client.getQueryCache().notify({
-			type: "observerOptionsUpdated",
-			query: this.#currentQuery,
-			observer: this
-		});
-		const mounted = this.hasListeners();
-		if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) this.#executeFetch();
-		this.updateResult();
-		if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) this.#updateStaleTimeout();
-		const nextRefetchInterval = this.#computeRefetchInterval();
-		if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) this.#updateRefetchInterval(nextRefetchInterval);
-	}
-	getOptimisticResult(options) {
-		const query = this.#client.getQueryCache().build(this.#client, options);
-		const result = this.createResult(query, options);
-		if (shouldAssignObserverCurrentProperties(this, result)) {
-			this.#currentResult = result;
-			this.#currentResultOptions = this.options;
-			this.#currentResultState = this.#currentQuery.state;
-		}
-		return result;
-	}
-	getCurrentResult() {
-		return this.#currentResult;
-	}
-	trackResult(result, onPropTracked) {
-		return new Proxy(result, { get: (target, key) => {
-			this.trackProp(key);
-			onPropTracked?.(key);
-			if (key === "promise") {
-				this.trackProp("data");
-				if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") this.#currentThenable.reject(/* @__PURE__ */ new Error("experimental_prefetchInRender feature flag is not enabled"));
-			}
-			return Reflect.get(target, key);
-		} });
-	}
-	trackProp(key) {
-		this.#trackedProps.add(key);
-	}
-	getCurrentQuery() {
-		return this.#currentQuery;
-	}
-	refetch({ ...options } = {}) {
-		return this.fetch({ ...options });
-	}
-	fetchOptimistic(options) {
-		const defaultedOptions = this.#client.defaultQueryOptions(options);
-		const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
-		return query.fetch().then(() => this.createResult(query, defaultedOptions));
-	}
-	fetch(fetchOptions) {
-		return this.#executeFetch({
-			...fetchOptions,
-			cancelRefetch: fetchOptions.cancelRefetch ?? true
-		}).then(() => {
-			this.updateResult();
-			return this.#currentResult;
-		});
-	}
-	#executeFetch(fetchOptions) {
-		this.#updateQuery();
-		let promise = this.#currentQuery.fetch(this.options, fetchOptions);
-		if (!fetchOptions?.throwOnError) promise = promise.catch(noop);
-		return promise;
-	}
-	#updateStaleTimeout() {
-		this.#clearStaleTimeout();
-		const staleTime = resolveStaleTime(this.options.staleTime, this.#currentQuery);
-		if (environmentManager.isServer() || this.#currentResult.isStale || !isValidTimeout(staleTime)) return;
-		const timeout = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime) + 1;
-		this.#staleTimeoutId = timeoutManager.setTimeout(() => {
-			if (!this.#currentResult.isStale) this.updateResult();
-		}, timeout);
-	}
-	#computeRefetchInterval() {
-		return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
-	}
-	#updateRefetchInterval(nextInterval) {
-		this.#clearRefetchInterval();
-		this.#currentRefetchInterval = nextInterval;
-		if (environmentManager.isServer() || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) return;
-		this.#refetchIntervalId = timeoutManager.setInterval(() => {
-			if (this.options.refetchIntervalInBackground || focusManager.isFocused()) this.#executeFetch();
-		}, this.#currentRefetchInterval);
-	}
-	#updateTimers() {
-		this.#updateStaleTimeout();
-		this.#updateRefetchInterval(this.#computeRefetchInterval());
-	}
-	#clearStaleTimeout() {
-		if (this.#staleTimeoutId) {
-			timeoutManager.clearTimeout(this.#staleTimeoutId);
-			this.#staleTimeoutId = void 0;
-		}
-	}
-	#clearRefetchInterval() {
-		if (this.#refetchIntervalId) {
-			timeoutManager.clearInterval(this.#refetchIntervalId);
-			this.#refetchIntervalId = void 0;
-		}
-	}
-	createResult(query, options) {
-		const prevQuery = this.#currentQuery;
-		const prevOptions = this.options;
-		const prevResult = this.#currentResult;
-		const prevResultState = this.#currentResultState;
-		const prevResultOptions = this.#currentResultOptions;
-		const queryInitialState = query !== prevQuery ? query.state : this.#currentQueryInitialState;
-		const { state } = query;
-		let newState = { ...state };
-		let isPlaceholderData = false;
-		let data;
-		if (options._optimisticResults) {
-			const mounted = this.hasListeners();
-			const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
-			const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-			if (fetchOnMount || fetchOptionally) newState = {
-				...newState,
-				...fetchState(state.data, query.options)
-			};
-			if (options._optimisticResults === "isRestoring") newState.fetchStatus = "idle";
-		}
-		let { error, errorUpdatedAt, status } = newState;
-		data = newState.data;
-		let skipSelect = false;
-		if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
-			let placeholderData;
-			if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
-				placeholderData = prevResult.data;
-				skipSelect = true;
-			} else placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
-			if (placeholderData !== void 0) {
-				status = "success";
-				data = replaceData(prevResult?.data, placeholderData, options);
-				isPlaceholderData = true;
-			}
-		}
-		if (options.select && data !== void 0 && !skipSelect) if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) data = this.#selectResult;
-		else try {
-			this.#selectFn = options.select;
-			data = options.select(data);
-			data = replaceData(prevResult?.data, data, options);
-			this.#selectResult = data;
-			this.#selectError = null;
-		} catch (selectError) {
-			this.#selectError = selectError;
-		}
-		if (this.#selectError) {
-			error = this.#selectError;
-			data = this.#selectResult;
-			errorUpdatedAt = Date.now();
-			status = "error";
-		}
-		const isFetching = newState.fetchStatus === "fetching";
-		const isPending = status === "pending";
-		const isError = status === "error";
-		const isLoading = isPending && isFetching;
-		const hasData = data !== void 0;
-		const nextResult = {
-			status,
-			fetchStatus: newState.fetchStatus,
-			isPending,
-			isSuccess: status === "success",
-			isError,
-			isInitialLoading: isLoading,
-			isLoading,
-			data,
-			dataUpdatedAt: newState.dataUpdatedAt,
-			error,
-			errorUpdatedAt,
-			failureCount: newState.fetchFailureCount,
-			failureReason: newState.fetchFailureReason,
-			errorUpdateCount: newState.errorUpdateCount,
-			isFetched: query.isFetched(),
-			isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
-			isFetching,
-			isRefetching: isFetching && !isPending,
-			isLoadingError: isError && !hasData,
-			isPaused: newState.fetchStatus === "paused",
-			isPlaceholderData,
-			isRefetchError: isError && hasData,
-			isStale: isStale(query, options),
-			refetch: this.refetch,
-			promise: this.#currentThenable,
-			isEnabled: resolveEnabled(options.enabled, query) !== false
-		};
-		if (this.options.experimental_prefetchInRender) {
-			const hasResultData = nextResult.data !== void 0;
-			const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
-			const finalizeThenableIfPossible = (thenable) => {
-				if (isErrorWithoutData) thenable.reject(nextResult.error);
-				else if (hasResultData) thenable.resolve(nextResult.data);
-			};
-			const recreateThenable = () => {
-				finalizeThenableIfPossible(this.#currentThenable = nextResult.promise = pendingThenable());
-			};
-			const prevThenable = this.#currentThenable;
-			switch (prevThenable.status) {
-				case "pending":
-					if (query.queryHash === prevQuery.queryHash) finalizeThenableIfPossible(prevThenable);
-					break;
-				case "fulfilled":
-					if (isErrorWithoutData || nextResult.data !== prevThenable.value) recreateThenable();
-					break;
-				case "rejected":
-					if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) recreateThenable();
-					break;
-			}
-		}
-		return nextResult;
-	}
-	updateResult() {
-		const prevResult = this.#currentResult;
-		const nextResult = this.createResult(this.#currentQuery, this.options);
-		this.#currentResultState = this.#currentQuery.state;
-		this.#currentResultOptions = this.options;
-		if (this.#currentResultState.data !== void 0) this.#lastQueryWithDefinedData = this.#currentQuery;
-		if (shallowEqualObjects(nextResult, prevResult)) return;
-		this.#currentResult = nextResult;
-		const shouldNotifyListeners = () => {
-			if (!prevResult) return true;
-			const { notifyOnChangeProps } = this.options;
-			const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
-			if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) return true;
-			const includedProps = new Set(notifyOnChangePropsValue ?? this.#trackedProps);
-			if (this.options.throwOnError) includedProps.add("error");
-			return Object.keys(this.#currentResult).some((key) => {
-				const typedKey = key;
-				return this.#currentResult[typedKey] !== prevResult[typedKey] && includedProps.has(typedKey);
-			});
-		};
-		this.#notify({ listeners: shouldNotifyListeners() });
-	}
-	#updateQuery() {
-		const query = this.#client.getQueryCache().build(this.#client, this.options);
-		if (query === this.#currentQuery) return;
-		const prevQuery = this.#currentQuery;
-		this.#currentQuery = query;
-		this.#currentQueryInitialState = query.state;
-		if (this.hasListeners()) {
-			prevQuery?.removeObserver(this);
-			query.addObserver(this);
-		}
-	}
-	onQueryUpdate() {
-		this.updateResult();
-		if (this.hasListeners()) this.#updateTimers();
-	}
-	#notify(notifyOptions) {
-		notifyManager.batch(() => {
-			if (notifyOptions.listeners) this.listeners.forEach((listener) => {
-				listener(this.#currentResult);
-			});
-			this.#client.getQueryCache().notify({
-				query: this.#currentQuery,
-				type: "observerResultsUpdated"
-			});
-		});
-	}
-};
-function shouldLoadOnMount(query, options) {
-	return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
-}
-function shouldFetchOnMount(query, options) {
-	return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
-}
-function shouldFetchOn(query, options, field) {
-	if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
-		const value = typeof field === "function" ? field(query) : field;
-		return value === "always" || value !== false && isStale(query, options);
-	}
-	return false;
-}
-function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-	return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
-}
-function isStale(query, options) {
-	return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
-}
-function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
-	if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) return true;
-	return false;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js
-var InfiniteQueryObserver = class extends QueryObserver {
-	constructor(client, options) {
-		super(client, options);
-	}
-	bindMethods() {
-		super.bindMethods();
-		this.fetchNextPage = this.fetchNextPage.bind(this);
-		this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
-	}
-	setOptions(options) {
-		super.setOptions({
-			...options,
-			behavior: infiniteQueryBehavior()
-		});
-	}
-	getOptimisticResult(options) {
-		options.behavior = infiniteQueryBehavior();
-		return super.getOptimisticResult(options);
-	}
-	fetchNextPage(options) {
-		return this.fetch({
-			...options,
-			meta: { fetchMore: { direction: "forward" } }
-		});
-	}
-	fetchPreviousPage(options) {
-		return this.fetch({
-			...options,
-			meta: { fetchMore: { direction: "backward" } }
-		});
-	}
-	createResult(query, options) {
-		const { state } = query;
-		const parentResult = super.createResult(query, options);
-		const { isFetching, isRefetching, isError, isRefetchError } = parentResult;
-		const fetchDirection = state.fetchMeta?.fetchMore?.direction;
-		const isFetchNextPageError = isError && fetchDirection === "forward";
-		const isFetchingNextPage = isFetching && fetchDirection === "forward";
-		const isFetchPreviousPageError = isError && fetchDirection === "backward";
-		const isFetchingPreviousPage = isFetching && fetchDirection === "backward";
-		return {
-			...parentResult,
-			fetchNextPage: this.fetchNextPage,
-			fetchPreviousPage: this.fetchPreviousPage,
-			hasNextPage: hasNextPage(options, state.data),
-			hasPreviousPage: hasPreviousPage(options, state.data),
-			isFetchNextPageError,
-			isFetchingNextPage,
-			isFetchPreviousPageError,
-			isFetchingPreviousPage,
-			isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,
-			isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
-		};
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/mutationObserver.js
-var MutationObserver = class extends Subscribable {
-	#client;
-	#currentResult = void 0;
-	#currentMutation;
-	#mutateOptions;
-	constructor(client, options) {
-		super();
-		this.#client = client;
-		this.setOptions(options);
-		this.bindMethods();
-		this.#updateResult();
-	}
-	bindMethods() {
-		this.mutate = this.mutate.bind(this);
-		this.reset = this.reset.bind(this);
-	}
-	setOptions(options) {
-		const prevOptions = this.options;
-		this.options = this.#client.defaultMutationOptions(options);
-		if (!shallowEqualObjects(this.options, prevOptions)) this.#client.getMutationCache().notify({
-			type: "observerOptionsUpdated",
-			mutation: this.#currentMutation,
-			observer: this
-		});
-		if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) this.reset();
-		else if (this.#currentMutation?.state.status === "pending") this.#currentMutation.setOptions(this.options);
-	}
-	onUnsubscribe() {
-		if (!this.hasListeners()) this.#currentMutation?.removeObserver(this);
-	}
-	onMutationUpdate(action) {
-		this.#updateResult();
-		this.#notify(action);
-	}
-	getCurrentResult() {
-		return this.#currentResult;
-	}
-	reset() {
-		this.#currentMutation?.removeObserver(this);
-		this.#currentMutation = void 0;
-		this.#updateResult();
-		this.#notify();
-	}
-	mutate(variables, options) {
-		this.#mutateOptions = options;
-		this.#currentMutation?.removeObserver(this);
-		this.#currentMutation = this.#client.getMutationCache().build(this.#client, this.options);
-		this.#currentMutation.addObserver(this);
-		return this.#currentMutation.execute(variables);
-	}
-	#updateResult() {
-		const state = this.#currentMutation?.state ?? getDefaultState();
-		this.#currentResult = {
-			...state,
-			isPending: state.status === "pending",
-			isSuccess: state.status === "success",
-			isError: state.status === "error",
-			isIdle: state.status === "idle",
-			mutate: this.mutate,
-			reset: this.reset
-		};
-	}
-	#notify(action) {
-		notifyManager.batch(() => {
-			if (this.#mutateOptions && this.hasListeners()) {
-				const variables = this.#currentResult.variables;
-				const onMutateResult = this.#currentResult.context;
-				const context = {
-					client: this.#client,
-					meta: this.options.meta,
-					mutationKey: this.options.mutationKey
-				};
-				if (action?.type === "success") {
-					try {
-						this.#mutateOptions.onSuccess?.(action.data, variables, onMutateResult, context);
-					} catch (e) {
-						Promise.reject(e);
-					}
-					try {
-						this.#mutateOptions.onSettled?.(action.data, null, variables, onMutateResult, context);
-					} catch (e) {
-						Promise.reject(e);
-					}
-				} else if (action?.type === "error") {
-					try {
-						this.#mutateOptions.onError?.(action.error, variables, onMutateResult, context);
-					} catch (e) {
-						Promise.reject(e);
-					}
-					try {
-						this.#mutateOptions.onSettled?.(void 0, action.error, variables, onMutateResult, context);
-					} catch (e) {
-						Promise.reject(e);
-					}
-				}
-			}
-			this.listeners.forEach((listener) => {
-				listener(this.#currentResult);
-			});
-		});
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
-var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
-var IsRestoringContext = import_react.createContext(false);
-var useIsRestoring = () => import_react.useContext(IsRestoringContext);
-IsRestoringContext.Provider;
-require_jsx_runtime();
-function createValue() {
-	let isReset = false;
-	return {
-		clearReset: () => {
-			isReset = false;
-		},
-		reset: () => {
-			isReset = true;
-		},
-		isReset: () => {
-			return isReset;
-		}
-	};
-}
-var QueryErrorResetBoundaryContext = import_react.createContext(createValue());
-var useQueryErrorResetBoundary = () => import_react.useContext(QueryErrorResetBoundaryContext);
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
-var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
-	const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
-	if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
-		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
-	}
-};
-var useClearResetErrorBoundary = (errorResetBoundary) => {
-	import_react.useEffect(() => {
-		errorResetBoundary.clearReset();
-	}, [errorResetBoundary]);
-};
-var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
-	return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
-};
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/suspense.js
-var ensureSuspenseTimers = (defaultedOptions) => {
-	if (defaultedOptions.suspense) {
-		const MIN_SUSPENSE_TIME_MS = 1e3;
-		const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
-		const originalStaleTime = defaultedOptions.staleTime;
-		defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
-		if (typeof defaultedOptions.gcTime === "number") defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, MIN_SUSPENSE_TIME_MS);
-	}
-};
-var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
-var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
-var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
-	errorResetBoundary.clearReset();
-});
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
-function useBaseQuery(options, Observer, queryClient) {
-	if (process.env.NODE_ENV !== "production") {
-		if (typeof options !== "object" || Array.isArray(options)) throw new Error("Bad argument type. Starting with v5, only the \"Object\" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object");
-	}
-	const isRestoring = useIsRestoring();
-	const errorResetBoundary = useQueryErrorResetBoundary();
-	const client = useQueryClient(queryClient);
-	const defaultedOptions = client.defaultQueryOptions(options);
-	client.getDefaultOptions().queries?._experimental_beforeQuery?.(defaultedOptions);
-	const query = client.getQueryCache().get(defaultedOptions.queryHash);
-	if (process.env.NODE_ENV !== "production") {
-		if (!defaultedOptions.queryFn) console.error(`[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`);
-	}
-	defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
-	ensureSuspenseTimers(defaultedOptions);
-	ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
-	useClearResetErrorBoundary(errorResetBoundary);
-	const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
-	const [observer] = import_react.useState(() => new Observer(client, defaultedOptions));
-	const result = observer.getOptimisticResult(defaultedOptions);
-	const shouldSubscribe = !isRestoring && options.subscribed !== false;
-	import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => {
-		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
-		observer.updateResult();
-		return unsubscribe;
-	}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
-	import_react.useEffect(() => {
-		observer.setOptions(defaultedOptions);
-	}, [defaultedOptions, observer]);
-	if (shouldSuspend(defaultedOptions, result)) throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
-	if (getHasError({
-		result,
-		errorResetBoundary,
-		throwOnError: defaultedOptions.throwOnError,
-		query,
-		suspense: defaultedOptions.suspense
-	})) throw result.error;
-	client.getDefaultOptions().queries?._experimental_afterQuery?.(defaultedOptions, result);
-	if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) (isNewCacheEntry ? fetchOptimistic(defaultedOptions, observer, errorResetBoundary) : query?.promise)?.catch(noop).finally(() => {
-		observer.updateResult();
-	});
-	return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useQuery.js
-function useQuery(options, queryClient) {
-	return useBaseQuery(options, QueryObserver, queryClient);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/queryOptions.js
-function queryOptions(options) {
-	return options;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/infiniteQueryOptions.js
-function infiniteQueryOptions(options) {
-	return options;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useMutation.js
-function useMutation(options, queryClient) {
-	const client = useQueryClient(queryClient);
-	const [observer] = import_react.useState(() => new MutationObserver(client, options));
-	import_react.useEffect(() => {
-		observer.setOptions(options);
-	}, [observer, options]);
-	const result = import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
-	const mutate = import_react.useCallback((variables, mutateOptions) => {
-		observer.mutate(variables, mutateOptions).catch(noop);
-	}, [observer]);
-	if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
-	return {
-		...result,
-		mutate,
-		mutateAsync: result.mutate
-	};
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.95.2_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js
-function useInfiniteQuery(options, queryClient) {
-	return useBaseQuery(options, InfiniteQueryObserver, queryClient);
-}
-//#endregion
-//#region src/services/services.generated.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
-var TokenService;
-(function(_TokenService) {
-	async function getToken(subset, id) {
-		return fetch({
-			method: "GET",
-			url: `/api/token/findById?${import_lib.default.stringify({
-				subset,
-				id
-			})}`
-		});
-	}
-	_TokenService.getToken = getToken;
-	const getTokenQueryOptions = _TokenService.getTokenQueryOptions = (subset, id) => queryOptions({
-		queryKey: [
-			"Token",
-			"getToken",
-			subset,
-			id
-		],
-		queryFn: () => getToken(subset, id)
-	});
-	_TokenService.useToken = (subset, id, options) => useRefreshable(useQuery({
-		...getTokenQueryOptions(subset, id),
-		...options
-	}));
-	async function getTokens(subset, rawParams) {
-		return fetch({
-			method: "GET",
-			url: `/api/token/findMany?${import_lib.default.stringify({
-				subset,
-				rawParams
-			})}`
-		});
-	}
-	_TokenService.getTokens = getTokens;
-	const getTokensQueryOptions = _TokenService.getTokensQueryOptions = (subset, rawParams) => queryOptions({
-		queryKey: [
-			"Token",
-			"getTokens",
-			subset,
-			rawParams
-		],
-		queryFn: () => getTokens(subset, rawParams)
-	});
-	_TokenService.useTokens = (subset, rawParams, options) => useRefreshable(useQuery({
-		...getTokensQueryOptions(subset, rawParams),
-		...options
-	}));
-	const getTokensInfiniteQueryOptions = _TokenService.getTokensInfiniteQueryOptions = (subset, rawParams) => infiniteQueryOptions({
-		queryKey: [
-			"Token",
-			"getTokens",
-			"infinite",
-			subset,
-			rawParams
-		],
-		queryFn: ({ pageParam }) => getTokens(subset, {
-			...rawParams,
-			page: pageParam
-		}),
-		initialPageParam: 1,
-		getNextPageParam: (lastPage, allPages) => {
-			const total = lastPage?.total ?? 0;
-			return allPages.reduce((sum, p) => sum + (p?.rows?.length ?? 0), 0) < total ? allPages.length + 1 : void 0;
-		},
-		select: dedupeAndFlatten
-	});
-	_TokenService.useTokensInfinite = (subset, rawParams, options) => useRefreshable(useInfiniteQuery({
-		...getTokensInfiniteQueryOptions(subset, rawParams),
-		...options
-	}));
-	async function save(spa) {
-		return fetch({
-			method: "POST",
-			url: `/api/token/save`,
-			data: { spa }
-		});
-	}
-	_TokenService.save = save;
-	_TokenService.useSaveMutation = () => useMutation({ mutationFn: (params) => save(params.spa) });
-	async function reorder(ids) {
-		return fetch({
-			method: "POST",
-			url: `/api/token/reorder`,
-			data: { ids }
-		});
-	}
-	_TokenService.reorder = reorder;
-	_TokenService.useReorderMutation = () => useMutation({ mutationFn: (params) => reorder(params.ids) });
-	async function del(ids) {
-		return fetch({
-			method: "POST",
-			url: `/api/token/del`,
-			data: { ids }
-		});
-	}
-	_TokenService.del = del;
-	_TokenService.useDelMutation = () => useMutation({ mutationFn: (params) => del(params.ids) });
-})(TokenService || (TokenService = {}));
-var SettingService;
-(function(_SettingService) {
-	async function getSetting(subset, id) {
-		return fetch({
-			method: "GET",
-			url: `/api/setting/findById?${import_lib.default.stringify({
-				subset,
-				id
-			})}`
-		});
-	}
-	_SettingService.getSetting = getSetting;
-	const getSettingQueryOptions = _SettingService.getSettingQueryOptions = (subset, id) => queryOptions({
-		queryKey: [
-			"Setting",
-			"getSetting",
-			subset,
-			id
-		],
-		queryFn: () => getSetting(subset, id)
-	});
-	_SettingService.useSetting = (subset, id, options) => useRefreshable(useQuery({
-		...getSettingQueryOptions(subset, id),
-		...options
-	}));
-	async function getSettings(subset, rawParams) {
-		return fetch({
-			method: "GET",
-			url: `/api/setting/findMany?${import_lib.default.stringify({
-				subset,
-				rawParams
-			})}`
-		});
-	}
-	_SettingService.getSettings = getSettings;
-	const getSettingsQueryOptions = _SettingService.getSettingsQueryOptions = (subset, rawParams) => queryOptions({
-		queryKey: [
-			"Setting",
-			"getSettings",
-			subset,
-			rawParams
-		],
-		queryFn: () => getSettings(subset, rawParams)
-	});
-	_SettingService.useSettings = (subset, rawParams, options) => useRefreshable(useQuery({
-		...getSettingsQueryOptions(subset, rawParams),
-		...options
-	}));
-	const getSettingsInfiniteQueryOptions = _SettingService.getSettingsInfiniteQueryOptions = (subset, rawParams) => infiniteQueryOptions({
-		queryKey: [
-			"Setting",
-			"getSettings",
-			"infinite",
-			subset,
-			rawParams
-		],
-		queryFn: ({ pageParam }) => getSettings(subset, {
-			...rawParams,
-			page: pageParam
-		}),
-		initialPageParam: 1,
-		getNextPageParam: (lastPage, allPages) => {
-			const total = lastPage?.total ?? 0;
-			return allPages.reduce((sum, p) => sum + (p?.rows?.length ?? 0), 0) < total ? allPages.length + 1 : void 0;
-		},
-		select: dedupeAndFlatten
-	});
-	_SettingService.useSettingsInfinite = (subset, rawParams, options) => useRefreshable(useInfiniteQuery({
-		...getSettingsInfiniteQueryOptions(subset, rawParams),
-		...options
-	}));
-	async function getSettingList() {
-		return fetch({
-			method: "GET",
-			url: `/api/setting/listSettings`
-		});
-	}
-	_SettingService.getSettingList = getSettingList;
-	const getSettingListQueryOptions = _SettingService.getSettingListQueryOptions = () => queryOptions({
-		queryKey: ["Setting", "getSettingList"],
-		queryFn: () => getSettingList()
-	});
-	_SettingService.useSettingList = (options) => useRefreshable(useQuery({
-		...getSettingListQueryOptions(),
-		...options
-	}));
-	async function updateSetting(key, value) {
-		return fetch({
-			method: "POST",
-			url: `/api/setting/updateSetting`,
-			data: {
-				key,
-				value
-			}
-		});
-	}
-	_SettingService.updateSetting = updateSetting;
-	_SettingService.useUpdateSettingMutation = () => useMutation({ mutationFn: (params) => updateSetting(params.key, params.value) });
-	async function resetSetting(key) {
-		return fetch({
-			method: "POST",
-			url: `/api/setting/resetSetting`,
-			data: { key }
-		});
-	}
-	_SettingService.resetSetting = resetSetting;
-	_SettingService.useResetSettingMutation = () => useMutation({ mutationFn: (params) => resetSetting(params.key) });
-	async function triggerExpiryReminder() {
-		return fetch({
-			method: "POST",
-			url: `/api/setting/triggerExpiryReminder`
-		});
-	}
-	_SettingService.triggerExpiryReminder = triggerExpiryReminder;
-	_SettingService.useTriggerExpiryReminderMutation = () => useMutation({ mutationFn: (params) => triggerExpiryReminder() });
-	async function restartServer() {
-		return fetch({
-			method: "POST",
-			url: `/api/setting/restartServer`
-		});
-	}
-	_SettingService.restartServer = restartServer;
-	_SettingService.useRestartServerMutation = () => useMutation({ mutationFn: (params) => restartServer() });
-})(SettingService || (SettingService = {}));
-var RequestLogStepService;
-(function(_RequestLogStepService) {
-	async function getRequestLogStep(subset, id) {
-		return fetch({
-			method: "GET",
-			url: `/api/requestLogStep/findById?${import_lib.default.stringify({
-				subset,
-				id
-			})}`
-		});
-	}
-	_RequestLogStepService.getRequestLogStep = getRequestLogStep;
-	const getRequestLogStepQueryOptions = _RequestLogStepService.getRequestLogStepQueryOptions = (subset, id) => queryOptions({
-		queryKey: [
-			"RequestLogStep",
-			"getRequestLogStep",
-			subset,
-			id
-		],
-		queryFn: () => getRequestLogStep(subset, id)
-	});
-	_RequestLogStepService.useRequestLogStep = (subset, id, options) => useRefreshable(useQuery({
-		...getRequestLogStepQueryOptions(subset, id),
-		...options
-	}));
-	async function getRequestLogSteps(subset, rawParams) {
-		return fetch({
-			method: "GET",
-			url: `/api/requestLogStep/findMany?${import_lib.default.stringify({
-				subset,
-				rawParams
-			})}`
-		});
-	}
-	_RequestLogStepService.getRequestLogSteps = getRequestLogSteps;
-	const getRequestLogStepsQueryOptions = _RequestLogStepService.getRequestLogStepsQueryOptions = (subset, rawParams) => queryOptions({
-		queryKey: [
-			"RequestLogStep",
-			"getRequestLogSteps",
-			subset,
-			rawParams
-		],
-		queryFn: () => getRequestLogSteps(subset, rawParams)
-	});
-	_RequestLogStepService.useRequestLogSteps = (subset, rawParams, options) => useRefreshable(useQuery({
-		...getRequestLogStepsQueryOptions(subset, rawParams),
-		...options
-	}));
-	const getRequestLogStepsInfiniteQueryOptions = _RequestLogStepService.getRequestLogStepsInfiniteQueryOptions = (subset, rawParams) => infiniteQueryOptions({
-		queryKey: [
-			"RequestLogStep",
-			"getRequestLogSteps",
-			"infinite",
-			subset,
-			rawParams
-		],
-		queryFn: ({ pageParam }) => getRequestLogSteps(subset, {
-			...rawParams,
-			page: pageParam
-		}),
-		initialPageParam: 1,
-		getNextPageParam: (lastPage, allPages) => {
-			const total = lastPage?.total ?? 0;
-			return allPages.reduce((sum, p) => sum + (p?.rows?.length ?? 0), 0) < total ? allPages.length + 1 : void 0;
-		},
-		select: dedupeAndFlatten
-	});
-	_RequestLogStepService.useRequestLogStepsInfinite = (subset, rawParams, options) => useRefreshable(useInfiniteQuery({
-		...getRequestLogStepsInfiniteQueryOptions(subset, rawParams),
-		...options
-	}));
-	async function save(spa) {
-		return fetch({
-			method: "POST",
-			url: `/api/requestLogStep/save`,
-			data: { spa }
-		});
-	}
-	_RequestLogStepService.save = save;
-	_RequestLogStepService.useSaveMutation = () => useMutation({ mutationFn: (params) => save(params.spa) });
-	async function del(ids) {
-		return fetch({
-			method: "POST",
-			url: `/api/requestLogStep/del`,
-			data: { ids }
-		});
-	}
-	_RequestLogStepService.del = del;
-	_RequestLogStepService.useDelMutation = () => useMutation({ mutationFn: (params) => del(params.ids) });
-})(RequestLogStepService || (RequestLogStepService = {}));
-var RequestLogService;
-(function(_RequestLogService) {
-	async function getRequestLog(subset, id) {
-		return fetch({
-			method: "GET",
-			url: `/api/requestLog/findById?${import_lib.default.stringify({
-				subset,
-				id
-			})}`
-		});
-	}
-	_RequestLogService.getRequestLog = getRequestLog;
-	const getRequestLogQueryOptions = _RequestLogService.getRequestLogQueryOptions = (subset, id) => queryOptions({
-		queryKey: [
-			"RequestLog",
-			"getRequestLog",
-			subset,
-			id
-		],
-		queryFn: () => getRequestLog(subset, id)
-	});
-	_RequestLogService.useRequestLog = (subset, id, options) => useRefreshable(useQuery({
-		...getRequestLogQueryOptions(subset, id),
-		...options
-	}));
-	async function getRequestLogs(subset, rawParams) {
-		return fetch({
-			method: "GET",
-			url: `/api/requestLog/findMany?${import_lib.default.stringify({
-				subset,
-				rawParams
-			})}`
-		});
-	}
-	_RequestLogService.getRequestLogs = getRequestLogs;
-	const getRequestLogsQueryOptions = _RequestLogService.getRequestLogsQueryOptions = (subset, rawParams) => queryOptions({
-		queryKey: [
-			"RequestLog",
-			"getRequestLogs",
-			subset,
-			rawParams
-		],
-		queryFn: () => getRequestLogs(subset, rawParams)
-	});
-	_RequestLogService.useRequestLogs = (subset, rawParams, options) => useRefreshable(useQuery({
-		...getRequestLogsQueryOptions(subset, rawParams),
-		...options
-	}));
-	const getRequestLogsInfiniteQueryOptions = _RequestLogService.getRequestLogsInfiniteQueryOptions = (subset, rawParams) => infiniteQueryOptions({
-		queryKey: [
-			"RequestLog",
-			"getRequestLogs",
-			"infinite",
-			subset,
-			rawParams
-		],
-		queryFn: ({ pageParam }) => getRequestLogs(subset, {
-			...rawParams,
-			page: pageParam
-		}),
-		initialPageParam: 1,
-		getNextPageParam: (lastPage, allPages) => {
-			const total = lastPage?.total ?? 0;
-			return allPages.reduce((sum, p) => sum + (p?.rows?.length ?? 0), 0) < total ? allPages.length + 1 : void 0;
-		},
-		select: dedupeAndFlatten
-	});
-	_RequestLogService.useRequestLogsInfinite = (subset, rawParams, options) => useRefreshable(useInfiniteQuery({
-		...getRequestLogsInfiniteQueryOptions(subset, rawParams),
-		...options
-	}));
-	async function save(spa) {
-		return fetch({
-			method: "POST",
-			url: `/api/requestLog/save`,
-			data: { spa }
-		});
-	}
-	_RequestLogService.save = save;
-	_RequestLogService.useSaveMutation = () => useMutation({ mutationFn: (params) => save(params.spa) });
-	async function del(ids) {
-		return fetch({
-			method: "POST",
-			url: `/api/requestLog/del`,
-			data: { ids }
-		});
-	}
-	_RequestLogService.del = del;
-	_RequestLogService.useDelMutation = () => useMutation({ mutationFn: (params) => del(params.ids) });
-})(RequestLogService || (RequestLogService = {}));
-var QgridService;
-(function(_QgridService) {
-	async function query(args) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/query`,
-			data: { args }
-		});
-	}
-	_QgridService.query = query;
-	_QgridService.useQueryMutation = () => useMutation({ mutationFn: (params) => query(params.args) });
-	async function prepareStream(args) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/prepareStream`,
-			data: { args }
-		});
-	}
-	_QgridService.prepareStream = prepareStream;
-	_QgridService.usePrepareStreamMutation = () => useMutation({ mutationFn: (params) => prepareStream(params.args) });
-	function useQueryStream(params, handlers, options) {
-		return useSSEStream(`/api/qgrid/queryStream`, params, handlers, options);
-	}
-	_QgridService.useQueryStream = useQueryStream;
-	async function createRun(input) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/createRun`,
-			data: { input }
-		});
-	}
-	_QgridService.createRun = createRun;
-	_QgridService.useCreateRunMutation = () => useMutation({ mutationFn: (params) => createRun(params.input) });
-	async function appendStep(input) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/appendStep`,
-			data: { input }
-		});
-	}
-	_QgridService.appendStep = appendStep;
-	_QgridService.useAppendStepMutation = () => useMutation({ mutationFn: (params) => appendStep(params.input) });
-	async function finishRun(input) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/finishRun`,
-			data: { input }
-		});
-	}
-	_QgridService.finishRun = finishRun;
-	_QgridService.useFinishRunMutation = () => useMutation({ mutationFn: (params) => finishRun(params.input) });
-	async function stats() {
-		return fetch({
-			method: "GET",
-			url: `/api/qgrid/stats`
-		});
-	}
-	_QgridService.stats = stats;
-	const statsQueryOptions = _QgridService.statsQueryOptions = () => queryOptions({
-		queryKey: ["Qgrid", "stats"],
-		queryFn: () => stats()
-	});
-	_QgridService.useStats = (options) => useRefreshable(useQuery({
-		...statsQueryOptions(),
-		...options
-	}));
-	async function totalCost(params) {
-		return fetch({
-			method: "GET",
-			url: `/api/qgrid/totalCost?${import_lib.default.stringify({ params })}`
-		});
-	}
-	_QgridService.totalCost = totalCost;
-	const totalCostQueryOptions = _QgridService.totalCostQueryOptions = (params) => queryOptions({
-		queryKey: [
-			"Qgrid",
-			"totalCost",
-			params
-		],
-		queryFn: () => totalCost(params)
-	});
-	_QgridService.useTotalCost = (params, options) => useRefreshable(useQuery({
-		...totalCostQueryOptions(params),
-		...options
-	}));
-	async function projectNames() {
-		return fetch({
-			method: "GET",
-			url: `/api/qgrid/projectNames`
-		});
-	}
-	_QgridService.projectNames = projectNames;
-	const projectNamesQueryOptions = _QgridService.projectNamesQueryOptions = () => queryOptions({
-		queryKey: ["Qgrid", "projectNames"],
-		queryFn: () => projectNames()
-	});
-	_QgridService.useProjectNames = (options) => useRefreshable(useQuery({
-		...projectNamesQueryOptions(),
-		...options
-	}));
-	async function modelNames() {
-		return fetch({
-			method: "GET",
-			url: `/api/qgrid/modelNames`
-		});
-	}
-	_QgridService.modelNames = modelNames;
-	const modelNamesQueryOptions = _QgridService.modelNamesQueryOptions = () => queryOptions({
-		queryKey: ["Qgrid", "modelNames"],
-		queryFn: () => modelNames()
-	});
-	_QgridService.useModelNames = (options) => useRefreshable(useQuery({
-		...modelNamesQueryOptions(),
-		...options
-	}));
-	async function addToken(provider, credentials, name) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/addToken`,
-			data: {
-				provider,
-				credentials,
-				name
-			}
-		});
-	}
-	_QgridService.addToken = addToken;
-	_QgridService.useAddTokenMutation = () => useMutation({ mutationFn: (params) => addToken(params.provider, params.credentials, params.name) });
-	async function updateToken(id, name, quotaThreshold, weight) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/updateToken`,
-			data: {
-				id,
-				name,
-				quotaThreshold,
-				weight
-			}
-		});
-	}
-	_QgridService.updateToken = updateToken;
-	async function removeToken(id) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/removeToken`,
-			data: { id }
-		});
-	}
-	_QgridService.removeToken = removeToken;
-	_QgridService.useRemoveTokenMutation = () => useMutation({ mutationFn: (params) => removeToken(params.id) });
-	async function toggleToken(id) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/toggleToken`,
-			data: { id }
-		});
-	}
-	_QgridService.toggleToken = toggleToken;
-	_QgridService.useToggleTokenMutation = () => useMutation({ mutationFn: (params) => toggleToken(params.id) });
-	async function oauthStart(name) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/oauthStart`,
-			data: { name }
-		});
-	}
-	_QgridService.oauthStart = oauthStart;
-	_QgridService.useOauthStartMutation = () => useMutation({ mutationFn: (params) => oauthStart(params.name) });
-	async function oauthComplete(pastedCode) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/oauthComplete`,
-			data: { pastedCode }
-		});
-	}
-	_QgridService.oauthComplete = oauthComplete;
-	_QgridService.useOauthCompleteMutation = () => useMutation({ mutationFn: (params) => oauthComplete(params.pastedCode) });
-	async function oauthStartOpenAI(name) {
-		return fetch({
-			method: "POST",
-			url: `/api/qgrid/oauthStartOpenAI`,
-			data: { name }
-		});
-	}
-	_QgridService.oauthStartOpenAI = oauthStartOpenAI;
-	_QgridService.useOauthStartOpenAIMutation = () => useMutation({ mutationFn: (params) => oauthStartOpenAI(params.name) });
-	async function usage(tokenId) {
-		return fetch({
-			method: "GET",
-			url: `/api/qgrid/usage?${import_lib.default.stringify({ tokenId })}`
-		});
-	}
-	_QgridService.usage = usage;
-	const usageQueryOptions = _QgridService.usageQueryOptions = (tokenId) => queryOptions({
-		queryKey: [
-			"Qgrid",
-			"usage",
-			tokenId
-		],
-		queryFn: () => usage(tokenId)
-	});
-	_QgridService.useUsage = (tokenId, options) => useRefreshable(useQuery({
-		...usageQueryOptions(tokenId),
-		...options
-	}));
-	async function health() {
-		return fetch({
-			method: "GET",
-			url: `/api/qgrid/health`
-		});
-	}
-	_QgridService.health = health;
-	const healthQueryOptions = _QgridService.healthQueryOptions = () => queryOptions({
-		queryKey: ["Qgrid", "health"],
-		queryFn: () => health()
-	});
-	_QgridService.useHealth = (options) => useRefreshable(useQuery({
-		...healthQueryOptions(),
-		...options
-	}));
-})(QgridService || (QgridService = {}));
-var MonitService;
-(function(_MonitService) {
-	async function monitLogs(cursor) {
-		return fetch({
-			method: "GET",
-			url: `/api/monit/monitLogs?${import_lib.default.stringify({ cursor })}`
-		});
-	}
-	_MonitService.monitLogs = monitLogs;
-	const monitLogsQueryOptions = _MonitService.monitLogsQueryOptions = (cursor) => queryOptions({
-		queryKey: [
-			"Monit",
-			"monitLogs",
-			cursor
-		],
-		queryFn: () => monitLogs(cursor)
-	});
-	_MonitService.useMonitLogs = (cursor, options) => useRefreshable(useQuery({
-		...monitLogsQueryOptions(cursor),
-		...options
-	}));
-	async function monitInfo() {
-		return fetch({
-			method: "GET",
-			url: `/api/monit/monitInfo`
-		});
-	}
-	_MonitService.monitInfo = monitInfo;
-	const monitInfoQueryOptions = _MonitService.monitInfoQueryOptions = () => queryOptions({
-		queryKey: ["Monit", "monitInfo"],
-		queryFn: () => monitInfo()
-	});
-	_MonitService.useMonitInfo = (options) => useRefreshable(useQuery({
-		...monitInfoQueryOptions(),
-		...options
-	}));
-})(MonitService || (MonitService = {}));
-RequestLogService.useRequestLogs, RequestLogService.useRequestLogsInfinite;
-RequestLogStepService.useRequestLogSteps, RequestLogStepService.useRequestLogStepsInfinite;
-SettingService.useSettings, SettingService.useSettingsInfinite;
-TokenService.useTokens, TokenService.useTokensInfinite;
-//#endregion
-export { SettingService as a, useQuery as c, RequestLogStepService as i, QgridService as n, TokenService as o, RequestLogService as r, useMutation as s, MonitService as t };