@cartanova/qgrid-cli 1.0.2 → 1.0.4

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

@@ -0,0 +1,836 @@
+import { B as noop, C as getDefaultState, D as notifyManager, F as hashKey, G as shallowEqualObjects, H as replaceData, J as timeUntilStale, K as shouldThrowError, L as isValidTimeout, O as pendingThenable, T as fetchState, U as resolveEnabled, W as resolveStaleTime, X as focusManager, Y as timeoutManager, Z as Subscribable, _ as require_lib, a as fetch, b as require_jsx_runtime, k as environmentManager, tt as __toESM, x as require_react, y as useQueryClient } from "./sd.generated-BnonqqKr.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/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/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 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) => 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) => useQuery({
+		...getTokensQueryOptions(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 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 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) => 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) => useQuery({
+		...getRequestLogsQueryOptions(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(prompt, system, timeout) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/query`,
+			data: {
+				prompt,
+				system,
+				timeout
+			}
+		});
+	}
+	_QgridService.query = query;
+	_QgridService.useQueryMutation = () => useMutation({ mutationFn: (params) => query(params.prompt, params.system, params.timeout) });
+	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) => useQuery({
+		...statsQueryOptions(),
+		...options
+	});
+	async function addToken(token, name, refreshToken) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/addToken`,
+			data: {
+				token,
+				name,
+				refreshToken
+			}
+		});
+	}
+	_QgridService.addToken = addToken;
+	_QgridService.useAddTokenMutation = () => useMutation({ mutationFn: (params) => addToken(params.token, params.name, params.refreshToken) });
+	async function updateToken(token, name, newToken, refreshToken) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/updateToken`,
+			data: {
+				token,
+				name,
+				newToken,
+				refreshToken
+			}
+		});
+	}
+	_QgridService.updateToken = updateToken;
+	_QgridService.useUpdateTokenMutation = () => useMutation({ mutationFn: (params) => updateToken(params.token, params.name, params.newToken, params.refreshToken) });
+	async function removeToken(token) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/removeToken`,
+			data: { token }
+		});
+	}
+	_QgridService.removeToken = removeToken;
+	_QgridService.useRemoveTokenMutation = () => useMutation({ mutationFn: (params) => removeToken(params.token) });
+	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 usage(tokenName) {
+		return fetch({
+			method: "GET",
+			url: `/api/qgrid/usage?${import_lib.default.stringify({ tokenName })}`
+		});
+	}
+	_QgridService.usage = usage;
+	const usageQueryOptions = _QgridService.usageQueryOptions = (tokenName) => queryOptions({
+		queryKey: [
+			"Qgrid",
+			"usage",
+			tokenName
+		],
+		queryFn: () => usage(tokenName)
+	});
+	_QgridService.useUsage = (tokenName, options) => useQuery({
+		...usageQueryOptions(tokenName),
+		...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) => useQuery({
+		...healthQueryOptions(),
+		...options
+	});
+})(QgridService || (QgridService = {}));
+RequestLogService.useRequestLogs;
+TokenService.useTokens;
+//#endregion
+export { RequestLogService as n, TokenService as r, QgridService as t };