New:Socket for Asana Is Now Available.Learn more →

@tanstack/react-query

Dependencies

Maintainers

Versions

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@tanstack/react-query - npm Package Compare versions

Comparing version

5.101.4

5.102.0

+1

build/legacy/errorBoundaryUtils.d.cts.map

{"version":3,"file":"errorBoundaryUtils.d.cts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;cAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;cAepC,6BACX,oBAAoB;cAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}

+1

build/legacy/errorBoundaryUtils.d.ts.map

{"version":3,"file":"errorBoundaryUtils.d.ts","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"mappings":";;;cAYa,kCACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,8BACP,cACA,QACA,OACA,YACA,YAEF,oBAAoB,8BACpB,OAAO,MAAM,cAAc,QAAQ,YAAY;cAepC,6BACX,oBAAoB;cAOT,cACX,OACA,QACA,cACA,YACA,kBAAkB,YAClB,QAAA,oBAAA,cAAA,OAAA;EAOA,QAAQ,oBAAoB,OAAO;EACnC,oBAAoB;EACpB,cAAc,aAAa,cAAc,QAAQ,YAAY;EAC7D,OAAO,MAAM,cAAc,QAAQ,YAAY;EAC/C"}

+1

build/legacy/HydrationBoundary.d.cts.map

{"version":3,"file":"HydrationBoundary.d.cts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;UAYiB;EACf,OAAO;EACP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;EAIZ,WAAW,MAAM;EACjB,cAAc;;cAGH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,2BAgFkB,MAAM"}

+1

build/legacy/HydrationBoundary.d.ts.map

{"version":3,"file":"HydrationBoundary.d.ts","names":[],"sources":["../../src/HydrationBoundary.tsx"],"mappings":";;;UAYiB;EACf,OAAO;EACP,UAAU,UAAU;IAClB,iBAAiB,UACf,QAAQ;;EAIZ,WAAW,MAAM;EACjB,cAAc;;cAGH,sBAAqB,UAAA,SAAA,OAAA,eAK/B,2BAgFkB,MAAM"}

+1

build/legacy/infiniteQueryOptions.d.cts.map

{"version":3,"file":"infiniteQueryOptions.d.cts","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"mappings":";;;KAYY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;EAEA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;KAIzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,wBAAwB,cAAc,QAAQ,OAAO,WAAW;EAGhE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;KAIQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;EAEA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;iBAI1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;iBAE7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;iBAE7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}

+1

build/legacy/infiniteQueryOptions.d.ts.map

{"version":3,"file":"infiniteQueryOptions.d.ts","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"mappings":";;;KAYY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;EAEA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;KAIzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,wBAAwB,cAAc,QAAQ,OAAO,WAAW;EAGhE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;KAIQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,wBACF,cACA,QACA,OACA,WACA;EAEA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;iBAI1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;iBAE7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;iBAE7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}

+1

build/legacy/IsRestoringProvider.d.cts.map

{"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;cAKa;cACA,qBAAmB,MAAA"}

+1

build/legacy/IsRestoringProvider.d.ts.map

{"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;cAKa;cACA,qBAAmB,MAAA"}

+1

build/legacy/mutationOptions.d.cts.map

{"version":3,"file":"mutationOptions.d.cts","names":[],"sources":["../../src/mutationOptions.ts"],"mappings":";;;iBAGgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,aACD,mBAAmB,OAAO,QAAQ,YAAY;iBAGhC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,KACD,mBAAmB,OAAO,QAAQ,YAAY"}

+1

build/legacy/mutationOptions.d.ts.map

{"version":3,"file":"mutationOptions.d.ts","names":[],"sources":["../../src/mutationOptions.ts"],"mappings":";;;iBAGgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,aACD,mBAAmB,OAAO,QAAQ,YAAY;iBAGhC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,mBAAmB,OAAO,QAAQ,YAAY,mCAG/C,KACD,mBAAmB,OAAO,QAAQ,YAAY"}

+1

build/legacy/QueryClientProvider.d.cts.map

{"version":3,"file":"QueryClientProvider.d.cts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;cAKa,oBAAkB,MAAA,QAAA;cAIlB,iBAAkB,cAAc,gBAAW;KAc5C;EACV,QAAQ;EACR,WAAW,MAAM;;cAGN,wBAAuB,QAAA,YAGjC,6BAA2B,MAAM,IAAI"}

+1

build/legacy/QueryClientProvider.d.ts.map

{"version":3,"file":"QueryClientProvider.d.ts","names":[],"sources":["../../src/QueryClientProvider.tsx"],"mappings":";;;cAKa,oBAAkB,MAAA,QAAA;cAIlB,iBAAkB,cAAc,gBAAW;KAc5C;EACV,QAAQ;EACR,WAAW,MAAM;;cAGN,wBAAuB,QAAA,YAGjC,6BAA2B,MAAM,IAAI"}

+1

build/legacy/QueryErrorResetBoundary.d.cts.map

{"version":3,"file":"QueryErrorResetBoundary.d.cts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;KAIY;KACA;KACA;UAEK;EACf,YAAY;EACZ,SAAS;EACT,OAAO;;cAsBI,kCAA0B;KAK3B,mCACV,OAAO,iCACJ,MAAM;UAEM;EACf,UAAU,kCAAkC,MAAM;;cAGvC,4BAA2B,YAErC,6DAA4B,IAAA"}

+1

build/legacy/QueryErrorResetBoundary.d.ts.map

{"version":3,"file":"QueryErrorResetBoundary.d.ts","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"mappings":";;KAIY;KACA;KACA;UAEK;EACf,YAAY;EACZ,SAAS;EACT,OAAO;;cAsBI,kCAA0B;KAK3B,mCACV,OAAO,iCACJ,MAAM;UAEM;EACf,UAAU,kCAAkC,MAAM;;cAGvC,4BAA2B,YAErC,6DAA4B,IAAA"}

+1

build/legacy/queryOptions.d.cts.map

{"version":3,"file":"queryOptions.d.cts","names":[],"sources":["../../src/queryOptions.ts"],"mappings":";;;KAYY,4BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,gBAAgB,cAAc,QAAQ,OAAO;EAC/C,0BAEI,oBAAoB,kBAAkB,iBACtC,kBAAkB;;KAGZ,uBACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,UAAU,QACR,gBAAgB,cAAc,QAAQ,OAAO,uBAC7C;;KAIQ,0BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,KAAK,gBAAgB,cAAc,QAAQ,OAAO;EACpD,aACI,kBAAkB,uBACX,kBAAkB;EAC7B,UAAU,cAAc,cAAc;;iBAGxB,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,aAC/D,0BAA0B,cAAc,QAAQ,OAAO,aACxD,oBAAoB,WAAW,cAAc;iBAE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,uBAAuB,cAAc,QAAQ,OAAO,aAC5D,uBAAuB,cAAc,QAAQ,OAAO,aACrD,oBAAoB,WAAW,cAAc;iBAE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,aACjE,4BAA4B,cAAc,QAAQ,OAAO,aAC1D,oBAAoB,WAAW,cAAc"}

+1

build/legacy/queryOptions.d.ts.map

{"version":3,"file":"queryOptions.d.ts","names":[],"sources":["../../src/queryOptions.ts"],"mappings":";;;KAYY,4BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,gBAAgB,cAAc,QAAQ,OAAO;EAC/C,0BAEI,oBAAoB,kBAAkB,iBACtC,kBAAkB;;KAGZ,uBACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,UAAU,QACR,gBAAgB,cAAc,QAAQ,OAAO,uBAC7C;;KAIQ,0BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,KAAK,gBAAgB,cAAc,QAAQ,OAAO;EACpD,aACI,kBAAkB,uBACX,kBAAkB;EAC7B,UAAU,cAAc,cAAc;;iBAGxB,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,aAC/D,0BAA0B,cAAc,QAAQ,OAAO,aACxD,oBAAoB,WAAW,cAAc;iBAE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,uBAAuB,cAAc,QAAQ,OAAO,aAC5D,uBAAuB,cAAc,QAAQ,OAAO,aACrD,oBAAoB,WAAW,cAAc;iBAE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,aACjE,4BAA4B,cAAc,QAAQ,OAAO,aAC1D,oBAAoB,WAAW,cAAc"}

+28

build/legacy/rolldown-runtime-VH7oDXx4.cjs

		//#region \0rolldown/runtime.js
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
		get: ((k) => from[k]).bind(null, key),
		enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable
		});
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode \|\| !mod \|\| !mod.__esModule \|\| !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
		value: mod,
		enumerable: true
		}) : target, mod));
		//#endregion
		Object.defineProperty(exports, "__toESM", {
		enumerable: true,
		get: function() {
		return __toESM;
		}
		});

+1

build/legacy/suspense.d.cts.map

{"version":3,"file":"suspense.d.cts","names":[],"sources":["../../src/suspense.ts"],"mappings":";;;cAUa,sBACX,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,QAAQ,QACR,OAAO,MAAM,cAAc,QAAQ,OAAO;cAG/B,uBACX,kBAAkB;cA2BP,gBACX,kBACI,oEAEJ,QAAQ;cAGG,kBACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,kBAAkB,8BAChB,cACA,QACA,OACA,YACA,YAEF,UAAU,cAAc,cAAc,QAAQ,OAAO,YAAY,YACjE,oBAAoB,iCAA4B,eAAA,oBAAA,OAAA"}

+1

build/legacy/suspense.d.ts.map

{"version":3,"file":"suspense.d.ts","names":[],"sources":["../../src/suspense.ts"],"mappings":";;;cAUa,sBACX,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,QAAQ,QACR,OAAO,MAAM,cAAc,QAAQ,OAAO;cAG/B,uBACX,kBAAkB;cA2BP,gBACX,kBACI,oEAEJ,QAAQ;cAGG,kBACX,cACA,QACA,OACA,YACA,kBAAkB,UAElB,kBAAkB,8BAChB,cACA,QACA,OACA,YACA,YAEF,UAAU,cAAc,cAAc,QAAQ,OAAO,YAAY,YACjE,oBAAoB,iCAA4B,eAAA,oBAAA,OAAA"}

+1

build/legacy/types.d.cts.map

{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/types.ts"],"mappings":";;KAuBY,yBAAyB;UAOpB,oBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;EAMA;;KAGU,wBACV,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,YAC3B,iBACF,oBAAoB,cAAc,QAAQ,OAAO,YAAY;EAG7D,UAAU,QACR,oBACE,cACA,QACA,OACA,YACA,uBAEF;;KAIQ,gCACV,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,iBACF,4BACE,cACA,QACA,OACA,WACA;EAIF,UAAU,QACR,4BACE,cACA,QACA,OACA,WACA,wBAEF;;KAIQ,qBAAqB;UAChB,gBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,oBAAoB,cAAc,QAAQ,OAAO,cAAc;KAIrD,6BAA6B;UAMxB,wBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,UAAU,QACR,gBAAgB,cAAc,QAAQ,OAAO,uBAC7C;;KAIQ,6BAA6B;UAOxB,wBACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;EAQF;;KAGU,qCACV;UACe,gCACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,wBAAwB,cAAc,QAAQ,OAAO,WAAW;EAGhE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;KAIQ,mBACV,iBACA,SAAS,gBACP,oBAAoB,OAAO;KAEnB,eACV,iBACA,SAAS,gBACP,mBAAmB,OAAO;KAElB,uBACV,iBACA,SAAS,gBACP,iBACF,2BAA2B,OAAO;KAIxB,sBACV,iBACA,SAAS,gBACP,2BAA2B,OAAO;KAE1B,uBACV,iBACA,SAAS,gBACP,4BAA4B,OAAO;KAE3B,8BACV,iBACA,SAAS,gBACP,mCAAmC,OAAO;KAElC,+BACV,iBACA,SAAS,gBACP,UACF,mCAAmC,OAAO;KAIhC,wBAAwB;UACnB,mBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;KAIzC,kBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;KAIlC,uBACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;KAElC,sBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,kBAAkB,OAAO,QAAQ,YAAY;;EAEvD,aAAa,uBACX,OACA,QACA,YACA;;KAIQ,kBACV,iBACA,SAAS,cACT,sBACA,6BACE,sBAAsB,OAAO,QAAQ,YAAY"}

+1

build/legacy/types.d.ts.map

{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types.ts"],"mappings":";;KAuBY,yBAAyB;UAOpB,oBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;EAMA;;KAGU,wBACV,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,YAC3B,iBACF,oBAAoB,cAAc,QAAQ,OAAO,YAAY;EAG7D,UAAU,QACR,oBACE,cACA,QACA,OACA,YACA,uBAEF;;KAIQ,gCACV,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,iBACF,4BACE,cACA,QACA,OACA,WACA;EAIF,UAAU,QACR,4BACE,cACA,QACA,OACA,WACA,wBAEF;;KAIQ,qBAAqB;UAChB,gBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,oBAAoB,cAAc,QAAQ,OAAO,cAAc;KAIrD,6BAA6B;UAMxB,wBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,UAAU,QACR,gBAAgB,cAAc,QAAQ,OAAO,uBAC7C;;KAIQ,6BAA6B;UAOxB,wBACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;EAQF;;KAGU,qCACV;UACe,gCACf,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,8BACQ,UACR,wBAAwB,cAAc,QAAQ,OAAO,WAAW;EAGhE,UAAU,QACR,wBACE,cACA,QACA,OACA,WACA,wBAEF;;KAIQ,mBACV,iBACA,SAAS,gBACP,oBAAoB,OAAO;KAEnB,eACV,iBACA,SAAS,gBACP,mBAAmB,OAAO;KAElB,uBACV,iBACA,SAAS,gBACP,iBACF,2BAA2B,OAAO;KAIxB,sBACV,iBACA,SAAS,gBACP,2BAA2B,OAAO;KAE1B,uBACV,iBACA,SAAS,gBACP,4BAA4B,OAAO;KAE3B,8BACV,iBACA,SAAS,gBACP,mCAAmC,OAAO;KAElC,+BACV,iBACA,SAAS,gBACP,UACF,mCAAmC,OAAO;KAIhC,wBAAwB;UACnB,mBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;KAIzC,kBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;KAIlC,uBACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;KAElC,sBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,kBAAkB,OAAO,QAAQ,YAAY;;EAEvD,aAAa,uBACX,OACA,QACA,YACA;;KAIQ,kBACV,iBACA,SAAS,cACT,sBACA,6BACE,sBAAsB,OAAO,QAAQ,YAAY"}

+1

build/legacy/useBaseQuery.d.cts.map

{"version":3,"file":"useBaseQuery.d.cts","names":[],"sources":["../../src/useBaseQuery.ts"],"mappings":";;;iBAyBgB,aACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,oBACP,cACA,QACA,OACA,YACA,YAEF,iBAAiB,eACjB,cAAc,cACb,oBAAoB,OAAO"}

+1

build/legacy/useBaseQuery.d.ts.map

{"version":3,"file":"useBaseQuery.d.ts","names":[],"sources":["../../src/useBaseQuery.ts"],"mappings":";;;iBAyBgB,aACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,SAAS,oBACP,cACA,QACA,OACA,YACA,YAEF,iBAAiB,eACjB,cAAc,cACb,oBAAoB,OAAO"}

+1

build/legacy/useInfiniteQuery.d.cts.map

{"version":3,"file":"useInfiniteQuery.d.cts","names":[],"sources":["../../src/useInfiniteQuery.ts"],"mappings":";;;;iBAoBgB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,8BAA8B,OAAO;iBAExB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO;iBAEjB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,wBACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO"}

+1

build/legacy/useInfiniteQuery.d.ts.map

{"version":3,"file":"useInfiniteQuery.d.ts","names":[],"sources":["../../src/useInfiniteQuery.ts"],"mappings":";;;;iBAoBgB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,8BAA8B,OAAO;iBAExB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO;iBAEjB,iBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,wBACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,uBAAuB,OAAO"}

+1

build/legacy/useIsFetching.d.cts.map

{"version":3,"file":"useIsFetching.d.cts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;iBAOgB,cACd,UAAU,cACV,cAAc"}

+1

build/legacy/useIsFetching.d.ts.map

{"version":3,"file":"useIsFetching.d.ts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;iBAOgB,cACd,UAAU,cACV,cAAc"}

+1

build/legacy/useMutation.d.cts.map

{"version":3,"file":"useMutation.d.cts","names":[],"sources":["../../src/useMutation.ts"],"mappings":";;;iBAkBgB,YACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,mBAAmB,OAAO,QAAQ,YAAY,kBACvD,cAAc,cACb,kBAAkB,OAAO,QAAQ,YAAY"}

+1

build/legacy/useMutation.d.ts.map

{"version":3,"file":"useMutation.d.ts","names":[],"sources":["../../src/useMutation.ts"],"mappings":";;;iBAkBgB,YACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,mBAAmB,OAAO,QAAQ,YAAY,kBACvD,cAAc,cACb,kBAAkB,OAAO,QAAQ,YAAY"}

+1

build/legacy/useMutationState.d.cts.map

{"version":3,"file":"useMutationState.d.cts","names":[],"sources":["../../src/useMutationState.ts"],"mappings":";;iBAagB,cACd,UAAU,iBACV,cAAc;KASX,uBAAuB,YAAY,kBACtC,oBACQ,aACA,cACA,kBACA,oBAGN,SAAS,OAAO,QAAQ,YAAY,mBACpC;KAEC,qBACH,UAAU,eACV,kBAAkB,+BAChB,uBAAuB;EAEzB,UAAU;EACV,UAAU,UAAU,cAAc;;iBAqBpB,iBACd,UAAU,eACV,kBAAkB,+BAChB,uBAAuB,UAEzB,UAAS,qBAAqB,SAAS,YACvC,cAAc,cACb,MAAM"}

+1

build/legacy/useMutationState.d.ts.map

{"version":3,"file":"useMutationState.d.ts","names":[],"sources":["../../src/useMutationState.ts"],"mappings":";;iBAagB,cACd,UAAU,iBACV,cAAc;KASX,uBAAuB,YAAY,kBACtC,oBACQ,aACA,cACA,kBACA,oBAGN,SAAS,OAAO,QAAQ,YAAY,mBACpC;KAEC,qBACH,UAAU,eACV,kBAAkB,+BAChB,uBAAuB;EAEzB,UAAU;EACV,UAAU,UAAU,cAAc;;iBAqBpB,iBACd,UAAU,eACV,kBAAkB,+BAChB,uBAAuB,UAEzB,UAAS,qBAAqB,SAAS,YACvC,cAAc,cACb,MAAM"}

+1

build/legacy/usePrefetchInfiniteQuery.d.cts.map

{"version":3,"file":"usePrefetchInfiniteQuery.d.cts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;iBAWgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}

+1

build/legacy/usePrefetchInfiniteQuery.d.ts.map

{"version":3,"file":"usePrefetchInfiniteQuery.d.ts","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"mappings":";;;iBAWgB,yBACd,wBACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc"}

+1

build/legacy/usePrefetchQuery.d.cts.map

{"version":3,"file":"usePrefetchQuery.d.cts","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"mappings":";;;iBAMgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,UAE7B,SAAS,wBACP,cACA,QACA,OACA,YACA,YAEF,cAAc"}

+1

build/legacy/usePrefetchQuery.d.ts.map

{"version":3,"file":"usePrefetchQuery.d.ts","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"mappings":";;;iBAMgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,UAE7B,SAAS,wBACP,cACA,QACA,OACA,YACA,YAEF,cAAc"}

+1

build/legacy/useQueries.d.cts.map

{"version":3,"file":"useQueries.d.cts","names":[],"sources":["../../src/useQueries.ts"],"mappings":";;;KAyCK,6BACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,gCAAgC,KAEnC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,6BAA6B,cAAc,QAAQ,SACnD;EAAY,mBAAmB;EAAc,cAAc;IACzD,6BAA6B,cAAc,UAC3C;EAAY,YAAY;EAAO,cAAc;IAC3C,sCAAsC,QAAQ,SAE9C,iBAAiB,oBAAoB,cAAc,SACjD,6BAA6B,cAAc,QAAQ,SACnD,iBAAiB,oBAAoB,UACnC,6BAA6B,cAAc,UAC3C,iBAAiB,gBACf,6BAA6B,gBAE7B;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,6BACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,eAAe,OAAO,UACtB,qBAAqB,QACnB,sBAAsB,OAAO,UAC7B,kCAAiC,sCACf,qBACd,eAAe,OAAO,UACtB,2BAA2B,QACzB,sBAAsB,OAAO,UAC7B,eAAe,OAAO,UAC1B,eAAe,OAAO,UAC5B,eAAe,OAAO;KAErB,kBAAkB,KAErB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;KAKN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,gCACN,oBAEE,iBAAiB,YACX,UAAU,gCAAgC,SAC9C,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,gCAAgC,YAC1C,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,mCACQ,oBACA,cACA,aACA,cAGV,MACE,6BACE,cACA,QACA,OACA,cAIJ,MAAM;;;;KAKR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,kBACN,oBAEE,iBAAiB,YACX,UAAU,kBAAkB,SAChC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,kBAAkB,YAC5B,iBAEH,WAAW,IAAI,kBAAkB,EAAE;iBAEhC,WACd,UAAU,YACV,kBAAkB,eAAe,MAG/B,YACG;EAEH,sBACiB,eAAe,sBACZ,WAAW,IAAI,gCAAgC,EAAE;EACrE,WAAW,QAAQ,eAAe,OAAO;EACzC;GAEF,cAAc,cACb"}

+1

build/legacy/useQueries.d.ts.map

{"version":3,"file":"useQueries.d.ts","names":[],"sources":["../../src/useQueries.ts"],"mappings":";;;KAyCK,6BACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,gBAAgB,cAAc,QAAQ,OAAO;EAG7C,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,gCAAgC,KAEnC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,6BAA6B,cAAc,QAAQ,SACnD;EAAY,mBAAmB;EAAc,cAAc;IACzD,6BAA6B,cAAc,UAC3C;EAAY,YAAY;EAAO,cAAc;IAC3C,sCAAsC,QAAQ,SAE9C,iBAAiB,oBAAoB,cAAc,SACjD,6BAA6B,cAAc,QAAQ,SACnD,iBAAiB,oBAAoB,UACnC,6BAA6B,cAAc,UAC3C,iBAAiB,gBACf,6BAA6B,gBAE7B;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,6BACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,eAAe,OAAO,UACtB,qBAAqB,QACnB,sBAAsB,OAAO,UAC7B,kCAAiC,sCACf,qBACd,eAAe,OAAO,UACtB,2BAA2B,QACzB,sBAAsB,OAAO,UAC7B,eAAe,OAAO,UAC1B,eAAe,OAAO,UAC5B,eAAe,OAAO;KAErB,kBAAkB,KAErB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;KAKN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,gCACN,oBAEE,iBAAiB,YACX,UAAU,gCAAgC,SAC9C,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,gCAAgC,YAC1C,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,mCACQ,oBACA,cACA,aACA,cAGV,MACE,6BACE,cACA,QACA,OACA,cAIJ,MAAM;;;;KAKR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,kBACN,oBAEE,iBAAiB,YACX,UAAU,kBAAkB,SAChC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,kBAAkB,YAC5B,iBAEH,WAAW,IAAI,kBAAkB,EAAE;iBAEhC,WACd,UAAU,YACV,kBAAkB,eAAe,MAG/B,YACG;EAEH,sBACiB,eAAe,sBACZ,WAAW,IAAI,gCAAgC,EAAE;EACrE,WAAW,QAAQ,eAAe,OAAO;EACzC;GAEF,cAAc,cACb"}

+1

build/legacy/useQuery.d.cts.map

{"version":3,"file":"useQuery.d.cts","names":[],"sources":["../../src/useQuery.ts"],"mappings":";;;;iBAcgB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,YAChE,cAAc,cACb,sBAAsB,OAAO;iBAEhB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,YAClE,cAAc,cACb,eAAe,OAAO;iBAET,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,gBAAgB,cAAc,QAAQ,OAAO,YACtD,cAAc,cACb,eAAe,OAAO"}

+1

build/legacy/useQuery.d.ts.map

{"version":3,"file":"useQuery.d.ts","names":[],"sources":["../../src/useQuery.ts"],"mappings":";;;;iBAcgB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,YAChE,cAAc,cACb,sBAAsB,OAAO;iBAEhB,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,YAClE,cAAc,cACb,eAAe,OAAO;iBAET,SACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,gBAAgB,cAAc,QAAQ,OAAO,YACtD,cAAc,cACb,eAAe,OAAO"}

+1

build/legacy/useSuspenseInfiniteQuery.d.cts.map

{"version":3,"file":"useSuspenseInfiniteQuery.d.cts","names":[],"sources":["../../src/useSuspenseInfiniteQuery.ts"],"mappings":";;;iBAiBgB,yBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,+BAA+B,OAAO"}

+1

build/legacy/useSuspenseInfiniteQuery.d.ts.map

{"version":3,"file":"useSuspenseInfiniteQuery.d.ts","names":[],"sources":["../../src/useSuspenseInfiniteQuery.ts"],"mappings":";;;iBAiBgB,yBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,gCACP,cACA,QACA,OACA,WACA,aAEF,cAAc,cACb,+BAA+B,OAAO"}

+1

build/legacy/useSuspenseQueries.d.cts.map

{"version":3,"file":"useSuspenseQueries.d.cts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":";;;KAaK;KAGA;KAEA,2BAA2B,KAE9B;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,wBAAwB,cAAc,QAAQ,SAC9C;EAAY,mBAAmB;EAAc,cAAc;IACzD,wBAAwB,cAAc,UACtC;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,QAAQ,SAEzC,iBAAiB,oBAAoB,cAAc,SACjD,wBAAwB,cAAc,QAAQ,SAC9C,iBAAiB,oBAAoB,UACnC,wBAAwB,cAAc,UACtC,iBAAiB,gBACf,wBAAwB,gBAExB;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,OACA,aAEF;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,cACA,aAGF;KAEf,0BAA0B,KAE7B;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,uBAAuB,OAAO,UAC9B;EAAY,mBAAmB;EAAc,cAAc;IACzD,uBAAuB,cAAc,UACrC;EAAY,YAAY;EAAO,cAAc;IAC3C,uBAAuB,OAAO,UAE9B,sBAAsB,cAAc,SAClC,uBAAuB,OAAO,UAC9B,iBAAiB,oBAAoB,UACnC,uBAAuB,cAAc,UACrC,iBAAiB,gBACf,uBAAuB,gBAEvB;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,uCACkB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAE1C;EACI,UACI,oBAAoB,qBACpB;EACJ,eAAe,wBAAwB;IAEzC,uBACE,8BACgB,SAAS,eAAe,UAG1C;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,2BACN,oBAEE,iBAAiB,YACX,UAAU,2BAA2B,SACzC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,2BAA2B,YACrC,cAEN,uBAAuB,IACrB,IAGA,UAAU,MACN,8BACQ,oBACA,cACA,aACA,cAGV,MACE,wBAAwB,cAAc,QAAQ,OAAO,cAGvD,MAAM;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,0BACN,oBAEE,iBAAiB,YACX,UAAU,0BAA0B,SACxC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,0BAA0B,YACpC,iBAEH,WAAW,IAAI,0BAA0B,EAAE;iBAExC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;EAChE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;iBAEa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBAAsB,uBAAuB;EAC7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}

+1

build/legacy/useSuspenseQueries.d.ts.map

{"version":3,"file":"useSuspenseQueries.d.ts","names":[],"sources":["../../src/useSuspenseQueries.ts"],"mappings":";;;KAaK;KAGA;KAEA,2BAA2B,KAE9B;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,wBAAwB,cAAc,QAAQ,SAC9C;EAAY,mBAAmB;EAAc,cAAc;IACzD,wBAAwB,cAAc,UACtC;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,QAAQ,SAEzC,iBAAiB,oBAAoB,cAAc,SACjD,wBAAwB,cAAc,QAAQ,SAC9C,iBAAiB,oBAAoB,UACnC,wBAAwB,cAAc,UACtC,iBAAiB,gBACf,wBAAwB,gBAExB;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,OACA,aAEF;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,eAAe,wBAAwB;IAEzC,wBACE,cACA,QACA,cACA,aAGF;KAEf,0BAA0B,KAE7B;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,uBAAuB,OAAO,UAC9B;EAAY,mBAAmB;EAAc,cAAc;IACzD,uBAAuB,cAAc,UACrC;EAAY,YAAY;EAAO,cAAc;IAC3C,uBAAuB,OAAO,UAE9B,sBAAsB,cAAc,SAClC,uBAAuB,OAAO,UAC9B,iBAAiB,oBAAoB,UACnC,uBAAuB,cAAc,UACrC,iBAAiB,gBACf,uBAAuB,gBAEvB;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,uCACkB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAE1C;EACI,UACI,oBAAoB,qBACpB;EACJ,eAAe,wBAAwB;IAEzC,uBACE,8BACgB,SAAS,eAAe,UAG1C;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,2BACN,oBAEE,iBAAiB,YACX,UAAU,2BAA2B,SACzC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,2BAA2B,YACrC,cAEN,uBAAuB,IACrB,IAGA,UAAU,MACN,8BACQ,oBACA,cACA,aACA,cAGV,MACE,wBAAwB,cAAc,QAAQ,OAAO,cAGvD,MAAM;;;;KAKR,uBACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,0BACN,oBAEE,iBAAiB,YACX,UAAU,0BAA0B,SACxC,iBAAiB,eAAe,SAC9B,2BACM,YACA,UAAU,0BAA0B,YACpC,iBAEH,WAAW,IAAI,0BAA0B,EAAE;iBAExC,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBACiB,uBAAuB,sBACpB,WAAW,IAAI,2BAA2B,EAAE;EAChE,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb;iBAEa,mBACd,UAAU,YACV,kBAAkB,uBAAuB,IAEzC;EACE,sBAAsB,uBAAuB;EAC7C,WAAW,QAAQ,uBAAuB,OAAO;GAEnD,cAAc,cACb"}

+1

build/legacy/useSuspenseQuery.d.cts.map

{"version":3,"file":"useSuspenseQuery.d.cts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;iBAOgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}

+1

build/legacy/useSuspenseQuery.d.ts.map

{"version":3,"file":"useSuspenseQuery.d.ts","names":[],"sources":["../../src/useSuspenseQuery.ts"],"mappings":";;;iBAOgB,iBACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,wBAAwB,cAAc,QAAQ,OAAO,YAC9D,cAAc,cACb,uBAAuB,OAAO"}

+1

build/modern/errorBoundaryUtils.d.cts.map

+1

build/modern/errorBoundaryUtils.d.ts.map

+1

build/modern/HydrationBoundary.d.cts.map

+1

build/modern/HydrationBoundary.d.ts.map

+1

build/modern/infiniteQueryOptions.d.cts.map

+1

build/modern/infiniteQueryOptions.d.ts.map

+1

build/modern/IsRestoringProvider.d.cts.map

{"version":3,"file":"IsRestoringProvider.d.cts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;cAKa;cACA,qBAAmB,MAAA"}

+1

build/modern/IsRestoringProvider.d.ts.map

{"version":3,"file":"IsRestoringProvider.d.ts","names":[],"sources":["../../src/IsRestoringProvider.ts"],"mappings":";;cAKa;cACA,qBAAmB,MAAA"}

+1

build/modern/mutationOptions.d.cts.map

+1

build/modern/mutationOptions.d.ts.map

+1

build/modern/QueryClientProvider.d.cts.map

+1

build/modern/QueryClientProvider.d.ts.map

+1

build/modern/QueryErrorResetBoundary.d.cts.map

+1

build/modern/QueryErrorResetBoundary.d.ts.map

+1

build/modern/queryOptions.d.cts.map

+1

build/modern/queryOptions.d.ts.map

+28

build/modern/rolldown-runtime-VH7oDXx4.cjs

		//#region \0rolldown/runtime.js
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
		get: ((k) => from[k]).bind(null, key),
		enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable
		});
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode \|\| !mod \|\| !mod.__esModule \|\| !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
		value: mod,
		enumerable: true
		}) : target, mod));
		//#endregion
		Object.defineProperty(exports, "__toESM", {
		enumerable: true,
		get: function() {
		return __toESM;
		}
		});

+1

build/modern/suspense.d.cts.map

+1

build/modern/suspense.d.ts.map

+1

build/modern/types.d.cts.map

+1

build/modern/types.d.ts.map

+1

build/modern/useBaseQuery.d.cts.map

+1

build/modern/useBaseQuery.d.ts.map

+1

build/modern/useInfiniteQuery.d.cts.map

+1

build/modern/useInfiniteQuery.d.ts.map

+1

build/modern/useIsFetching.d.cts.map

{"version":3,"file":"useIsFetching.d.cts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;iBAOgB,cACd,UAAU,cACV,cAAc"}

+1

build/modern/useIsFetching.d.ts.map

{"version":3,"file":"useIsFetching.d.ts","names":[],"sources":["../../src/useIsFetching.ts"],"mappings":";;iBAOgB,cACd,UAAU,cACV,cAAc"}

+1

build/modern/useMutation.d.cts.map

+1

build/modern/useMutation.d.ts.map

+1

build/modern/useMutationState.d.cts.map

+1

build/modern/useMutationState.d.ts.map

+1

build/modern/usePrefetchInfiniteQuery.d.cts.map

+1

build/modern/usePrefetchInfiniteQuery.d.ts.map

+1

build/modern/usePrefetchQuery.d.cts.map

+1

build/modern/usePrefetchQuery.d.ts.map

+1

build/modern/useQueries.d.cts.map

+1

build/modern/useQueries.d.ts.map

+1

build/modern/useQuery.d.cts.map

+1

build/modern/useQuery.d.ts.map

+1

build/modern/useSuspenseInfiniteQuery.d.cts.map

+1

build/modern/useSuspenseInfiniteQuery.d.ts.map

+1

build/modern/useSuspenseQueries.d.cts.map

+1

build/modern/useSuspenseQueries.d.ts.map

+1

build/modern/useSuspenseQuery.d.cts.map

+1

build/modern/useSuspenseQuery.d.ts.map

+22

-64

build/legacy/errorBoundaryUtils.cjs

		@@ -1,69 +0,27 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/errorBoundaryUtils.ts
		const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
		const throwOnError = (query === null \|\| query === void 0 ? void 0 : query.state.error) && typeof options.throwOnError === "function" ? (0, _tanstack_query_core.shouldThrowError)(options.throwOnError, [query.state.error, query]) : options.throwOnError;
		if (options.suspense \|\| throwOnError) {
		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
		}
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		const useClearResetErrorBoundary = (errorResetBoundary) => {
		react.useEffect(() => {
		errorResetBoundary.clearReset();
		}, [errorResetBoundary]);
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		const getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
		return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 \|\| (0, _tanstack_query_core.shouldThrowError)(throwOnError, [result.error, query]));
		};
		//#endregion
		exports.ensurePreventErrorBoundaryRetry = ensurePreventErrorBoundaryRetry;
		exports.getHasError = getHasError;
		exports.useClearResetErrorBoundary = useClearResetErrorBoundary;

		// src/errorBoundaryUtils.ts
		var errorBoundaryUtils_exports = {};
		__export(errorBoundaryUtils_exports, {
		ensurePreventErrorBoundaryRetry: () => ensurePreventErrorBoundaryRetry,
		getHasError: () => getHasError,
		useClearResetErrorBoundary: () => useClearResetErrorBoundary
		});
		module.exports = __toCommonJS(errorBoundaryUtils_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
		const throwOnError = (query == null ? void 0 : query.state.error) && typeof options.throwOnError === "function" ? (0, import_query_core.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) => {
		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 \|\| (0, import_query_core.shouldThrowError)(throwOnError, [result.error, query]));
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		});
		//# sourceMappingURL=errorBoundaryUtils.cjs.map

+1

-1

build/legacy/errorBoundaryUtils.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (\n options.suspense \|\|\n options.experimental_prefetchInRender \|\|\n throwOnError\n ) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AACvB,wBAAiC;AAU1B,IAAM,kCAAkC,CAO7C,SAOA,oBACA,UACG;AACH,QAAM,gBACJ,+BAAO,MAAM,UAAS,OAAO,QAAQ,iBAAiB,iBAClD,oCAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;AAEd,MACE,QAAQ,YACR,QAAQ,iCACR,cACA;AAEA,QAAI,CAAC,mBAAmB,QAAQ,GAAG;AACjC,cAAQ,eAAe;AAAA,IACzB;AAAA,EACF;AACF;AAEO,IAAM,6BAA6B,CACxC,uBACG;AACH,EAAM,gBAAU,MAAM;AACpB,uBAAmB,WAAW;AAAA,EAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEO,IAAM,cAAc,CAMzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAMM;AACJ,SACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,cAC5B,oCAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D;","names":[]}
		{"version":3,"file":"errorBoundaryUtils.cjs","names":["shouldThrowError"],"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (options.suspense \|\| throwOnError) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;;;;;AAYA,MAAa,mCAOX,SAOA,oBACA,UACG;CACH,MAAM,gBAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACJ,MAAO,MAAM,UAAS,OAAO,QAAQ,iBAAiB,cAAA,GAClDA,qBAAAA,iBAAAA,CAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;CAEd,IAAI,QAAQ,YAAY,cAElB;MAAA,CAAC,mBAAmB,QAAQ,GAC9B,QAAQ,eAAe;CAAA;AAG7B;AAEA,MAAa,8BACX,uBACG;CACH,MAAM,gBAAgB;EACpB,mBAAmB,WAAW;CAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEA,MAAa,eAMX,EACA,QACA,oBACA,cACA,OACA,eAOI;CACJ,OACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,KAAA,MAAA,GAC5BA,qBAAAA,iBAAAA,CAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D"}

+15

-3

build/legacy/errorBoundaryUtils.d.cts

		@@ -1,3 +0,15 @@
		export { ensurePreventErrorBoundaryRetry } from './_tsup-dts-rollup.cjs';
		export { useClearResetErrorBoundary } from './_tsup-dts-rollup.cjs';
		export { getHasError } from './_tsup-dts-rollup.cjs';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.cjs";
		import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
		//#region src/errorBoundaryUtils.d.ts
		declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;
		declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
		declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;
		//#endregion
		export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
		//# sourceMappingURL=errorBoundaryUtils.d.cts.map

+15

-3

build/legacy/errorBoundaryUtils.d.ts

		@@ -1,3 +0,15 @@
		export { ensurePreventErrorBoundaryRetry } from './_tsup-dts-rollup.js';
		export { useClearResetErrorBoundary } from './_tsup-dts-rollup.js';
		export { getHasError } from './_tsup-dts-rollup.js';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.js";
		import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
		//#region src/errorBoundaryUtils.d.ts
		declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;
		declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
		declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;
		//#endregion
		export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
		//# sourceMappingURL=errorBoundaryUtils.d.ts.map

+15

-26

build/legacy/errorBoundaryUtils.js

		"use client";

		// src/errorBoundaryUtils.ts
		import * as React from "react";
		import { shouldThrowError } from "@tanstack/query-core";
		var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
		const throwOnError = (query == null ? void 0 : 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;
		}
		}
		//#region src/errorBoundaryUtils.ts
		const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
		const throwOnError = (query === null \|\| query === void 0 ? void 0 : query.state.error) && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
		if (options.suspense \|\| throwOnError) {
		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
		}
		};
		var useClearResetErrorBoundary = (errorResetBoundary) => {
		React.useEffect(() => {
		errorResetBoundary.clearReset();
		}, [errorResetBoundary]);
		const useClearResetErrorBoundary = (errorResetBoundary) => {
		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]));
		const getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
		return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 \|\| shouldThrowError(throwOnError, [result.error, query]));
		};
		export {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		};
		//#endregion
		export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };

		//# sourceMappingURL=errorBoundaryUtils.js.map

+1

-1

build/legacy/errorBoundaryUtils.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (\n options.suspense \|\|\n options.experimental_prefetchInRender \|\|\n throwOnError\n ) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AACvB,SAAS,wBAAwB;AAU1B,IAAM,kCAAkC,CAO7C,SAOA,oBACA,UACG;AACH,QAAM,gBACJ,+BAAO,MAAM,UAAS,OAAO,QAAQ,iBAAiB,aAClD,iBAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;AAEd,MACE,QAAQ,YACR,QAAQ,iCACR,cACA;AAEA,QAAI,CAAC,mBAAmB,QAAQ,GAAG;AACjC,cAAQ,eAAe;AAAA,IACzB;AAAA,EACF;AACF;AAEO,IAAM,6BAA6B,CACxC,uBACG;AACH,EAAM,gBAAU,MAAM;AACpB,uBAAmB,WAAW;AAAA,EAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEO,IAAM,cAAc,CAMzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAMM;AACJ,SACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,UAC5B,iBAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D;","names":[]}
		{"version":3,"file":"errorBoundaryUtils.js","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (options.suspense \|\| throwOnError) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;;AAYA,MAAa,mCAOX,SAOA,oBACA,UACG;CACH,MAAM,gBAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IACJ,MAAO,MAAM,UAAS,OAAO,QAAQ,iBAAiB,aAClD,iBAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;CAEd,IAAI,QAAQ,YAAY,cAElB;MAAA,CAAC,mBAAmB,QAAQ,GAC9B,QAAQ,eAAe;CAAA;AAG7B;AAEA,MAAa,8BACX,uBACG;CACH,MAAM,gBAAgB;EACpB,mBAAmB,WAAW;CAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEA,MAAa,eAMX,EACA,QACA,oBACA,cACA,OACA,eAOI;CACJ,OACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,KAAA,KAC5B,iBAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D"}

+35

-87

build/legacy/HydrationBoundary.cjs

		@@ -1,91 +0,39 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/HydrationBoundary.tsx
		const HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const optionsRef = react.useRef(options);
		react.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = react.useMemo(() => {
		if (state) {
		if (typeof state !== "object") return;
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) newQueries.push(dehydratedQuery);
		else if (dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt) existingQueries.push(dehydratedQuery);
		}
		if (newQueries.length > 0) (0, _tanstack_query_core.hydrate)(client, { queries: newQueries }, optionsRef.current);
		if (existingQueries.length > 0) return existingQueries;
		}
		}, [client, state]);
		react.useEffect(() => {
		if (hydrationQueue) (0, _tanstack_query_core.hydrate)(client, { queries: hydrationQueue }, optionsRef.current);
		}, [client, hydrationQueue]);
		return children;
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		//#endregion
		exports.HydrationBoundary = HydrationBoundary;

		// src/HydrationBoundary.tsx
		var HydrationBoundary_exports = {};
		__export(HydrationBoundary_exports, {
		HydrationBoundary: () => HydrationBoundary
		});
		module.exports = __toCommonJS(HydrationBoundary_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var HydrationBoundary = ({
		children,
		options = {},
		state,
		queryClient
		}) => {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const optionsRef = React.useRef(options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = React.useMemo(() => {
		if (state) {
		if (typeof state !== "object") {
		return;
		}
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) {
		newQueries.push(dehydratedQuery);
		} else {
		const hydrationIsNewer = dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt;
		if (hydrationIsNewer) {
		existingQueries.push(dehydratedQuery);
		}
		}
		}
		if (newQueries.length > 0) {
		(0, import_query_core.hydrate)(client, { queries: newQueries }, optionsRef.current);
		}
		if (existingQueries.length > 0) {
		return existingQueries;
		}
		}
		return void 0;
		}, [client, state]);
		React.useEffect(() => {
		if (hydrationQueue) {
		(0, import_query_core.hydrate)(client, { queries: hydrationQueue }, optionsRef.current);
		}
		}, [client, hydrationQueue]);
		return children;
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		HydrationBoundary
		});
		//# sourceMappingURL=HydrationBoundary.cjs.map

+1

-1

build/legacy/HydrationBoundary.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAAwB;AACxB,iCAA+B;AAoBxB,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA,UAAU,CAAC;AAAA,EACX;AAAA,EACA;AACF,MAA8B;AAC5B,QAAM,aAAS,2CAAe,WAAW;AAEzC,QAAM,aAAmB,aAAO,OAAO;AACvC,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAiBD,QAAM,iBACE,cAAQ,MAAM;AAClB,QAAI,OAAO;AACT,UAAI,OAAO,UAAU,UAAU;AAC7B;AAAA,MACF;AAEA,YAAM,aAAa,OAAO,cAAc;AAKxC,YAAM,UAAU,MAAM,WAAW,CAAC;AAElC,YAAM,aAAyC,CAAC;AAChD,YAAM,kBAA8C,CAAC;AACrD,iBAAW,mBAAmB,SAAS;AACrC,cAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;AAE9D,YAAI,CAAC,eAAe;AAClB,qBAAW,KAAK,eAAe;AAAA,QACjC,OAAO;AACL,gBAAM,mBACJ,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,UACjC,gBAAgB,eACd,cAAc,MAAM;AAE1B,cAAI,kBAAkB;AACpB,4BAAgB,KAAK,eAAe;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,UAAI,WAAW,SAAS,GAAG;AAIzB,uCAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;AAAA,MAC7D;AACA,UAAI,gBAAgB,SAAS,GAAG;AAC9B,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,CAAC,QAAQ,KAAK,CAAC;AAEpB,EAAM,gBAAU,MAAM;AACpB,QAAI,gBAAgB;AAClB,qCAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;AAAA,IACjE;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,CAAC;AAE3B,SAAO;AACT;","names":[]}
		{"version":3,"file":"HydrationBoundary.cjs","names":["useQueryClient","React"],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;;;;;;AAwBA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,MAAM,aAAaC,MAAM,OAAO,OAAO;CACvC,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,iBACJA,MAAM,cAAc;EAClB,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAKxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAY/B,IATE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eACd,cAAc,MAAM,eAGxB,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAItB,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAEpB,MAAM,gBAAgB;EACpB,IAAI,gBACF,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO;AACT"}

+15

-2

build/legacy/HydrationBoundary.d.cts

		@@ -1,2 +0,15 @@
		export { HydrationBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { HydrationBoundary } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		import { DehydratedState, HydrateOptions, OmitKeyof, QueryClient } from "@tanstack/query-core";
		//#region src/HydrationBoundary.d.ts
		interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React.ReactNode;
		queryClient?: QueryClient;
		}
		declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => React.ReactElement;
		//#endregion
		export { HydrationBoundary, HydrationBoundaryProps };
		//# sourceMappingURL=HydrationBoundary.d.cts.map

+15

-2

build/legacy/HydrationBoundary.d.ts

		@@ -1,2 +0,15 @@
		export { HydrationBoundaryProps } from './_tsup-dts-rollup.js';
		export { HydrationBoundary } from './_tsup-dts-rollup.js';
		import * as React from "react";
		import { DehydratedState, HydrateOptions, OmitKeyof, QueryClient } from "@tanstack/query-core";
		//#region src/HydrationBoundary.d.ts
		interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React.ReactNode;
		queryClient?: QueryClient;
		}
		declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => React.ReactElement;
		//#endregion
		export { HydrationBoundary, HydrationBoundaryProps };
		//# sourceMappingURL=HydrationBoundary.d.ts.map

+31

-52

build/legacy/HydrationBoundary.js

		"use client";

		// src/HydrationBoundary.tsx
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import { hydrate } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		var HydrationBoundary = ({
		children,
		options = {},
		state,
		queryClient
		}) => {
		const client = useQueryClient(queryClient);
		const optionsRef = React.useRef(options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = React.useMemo(() => {
		if (state) {
		if (typeof state !== "object") {
		return;
		}
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) {
		newQueries.push(dehydratedQuery);
		} else {
		const hydrationIsNewer = dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt;
		if (hydrationIsNewer) {
		existingQueries.push(dehydratedQuery);
		}
		}
		}
		if (newQueries.length > 0) {
		hydrate(client, { queries: newQueries }, optionsRef.current);
		}
		if (existingQueries.length > 0) {
		return existingQueries;
		}
		}
		return void 0;
		}, [client, state]);
		React.useEffect(() => {
		if (hydrationQueue) {
		hydrate(client, { queries: hydrationQueue }, optionsRef.current);
		}
		}, [client, hydrationQueue]);
		return children;
		//#region src/HydrationBoundary.tsx
		const HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
		const client = useQueryClient(queryClient);
		const optionsRef = React.useRef(options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = React.useMemo(() => {
		if (state) {
		if (typeof state !== "object") return;
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) newQueries.push(dehydratedQuery);
		else if (dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt) existingQueries.push(dehydratedQuery);
		}
		if (newQueries.length > 0) hydrate(client, { queries: newQueries }, optionsRef.current);
		if (existingQueries.length > 0) return existingQueries;
		}
		}, [client, state]);
		React.useEffect(() => {
		if (hydrationQueue) hydrate(client, { queries: hydrationQueue }, optionsRef.current);
		}, [client, hydrationQueue]);
		return children;
		};
		export {
		HydrationBoundary
		};
		//#endregion
		export { HydrationBoundary };

		//# sourceMappingURL=HydrationBoundary.js.map

+1

-1

build/legacy/HydrationBoundary.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAoBxB,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA,UAAU,CAAC;AAAA,EACX;AAAA,EACA;AACF,MAA8B;AAC5B,QAAM,SAAS,eAAe,WAAW;AAEzC,QAAM,aAAmB,aAAO,OAAO;AACvC,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAiBD,QAAM,iBACE,cAAQ,MAAM;AAClB,QAAI,OAAO;AACT,UAAI,OAAO,UAAU,UAAU;AAC7B;AAAA,MACF;AAEA,YAAM,aAAa,OAAO,cAAc;AAKxC,YAAM,UAAU,MAAM,WAAW,CAAC;AAElC,YAAM,aAAyC,CAAC;AAChD,YAAM,kBAA8C,CAAC;AACrD,iBAAW,mBAAmB,SAAS;AACrC,cAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;AAE9D,YAAI,CAAC,eAAe;AAClB,qBAAW,KAAK,eAAe;AAAA,QACjC,OAAO;AACL,gBAAM,mBACJ,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,UACjC,gBAAgB,eACd,cAAc,MAAM;AAE1B,cAAI,kBAAkB;AACpB,4BAAgB,KAAK,eAAe;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,UAAI,WAAW,SAAS,GAAG;AAIzB,gBAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;AAAA,MAC7D;AACA,UAAI,gBAAgB,SAAS,GAAG;AAC9B,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,CAAC,QAAQ,KAAK,CAAC;AAEpB,EAAM,gBAAU,MAAM;AACpB,QAAI,gBAAgB;AAClB,cAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;AAAA,IACjE;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,CAAC;AAE3B,SAAO;AACT;","names":[]}
		{"version":3,"file":"HydrationBoundary.js","names":[],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;;;AAwBA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAAS,eAAe,WAAW;CAEzC,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,iBACJ,MAAM,cAAc;EAClB,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAKxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAY/B,IATE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eACd,cAAc,MAAM,eAGxB,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAItB,QAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAEpB,MAAM,gBAAgB;EACpB,IAAI,gBACF,QAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO;AACT"}

+54

-95

build/legacy/index.cjs

		@@ -1,97 +0,56 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		const require_HydrationBoundary = require("./HydrationBoundary.cjs");
		const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		const require_useQueries = require("./useQueries.cjs");
		const require_useQuery = require("./useQuery.cjs");
		const require_useSuspenseQuery = require("./useSuspenseQuery.cjs");
		const require_useSuspenseInfiniteQuery = require("./useSuspenseInfiniteQuery.cjs");
		const require_useSuspenseQueries = require("./useSuspenseQueries.cjs");
		const require_usePrefetchQuery = require("./usePrefetchQuery.cjs");
		const require_usePrefetchInfiniteQuery = require("./usePrefetchInfiniteQuery.cjs");
		const require_queryOptions = require("./queryOptions.cjs");
		const require_infiniteQueryOptions = require("./infiniteQueryOptions.cjs");
		const require_useIsFetching = require("./useIsFetching.cjs");
		const require_useMutationState = require("./useMutationState.cjs");
		const require_useMutation = require("./useMutation.cjs");
		const require_mutationOptions = require("./mutationOptions.cjs");
		const require_useInfiniteQuery = require("./useInfiniteQuery.cjs");
		//#region src/index.ts
		/* istanbul ignore file */
		//#endregion
		exports.HydrationBoundary = require_HydrationBoundary.HydrationBoundary;
		exports.IsRestoringProvider = require_IsRestoringProvider.IsRestoringProvider;
		exports.QueryClientContext = require_QueryClientProvider.QueryClientContext;
		exports.QueryClientProvider = require_QueryClientProvider.QueryClientProvider;
		exports.QueryErrorResetBoundary = require_QueryErrorResetBoundary.QueryErrorResetBoundary;
		exports.infiniteQueryOptions = require_infiniteQueryOptions.infiniteQueryOptions;
		exports.mutationOptions = require_mutationOptions.mutationOptions;
		exports.queryOptions = require_queryOptions.queryOptions;
		exports.useInfiniteQuery = require_useInfiniteQuery.useInfiniteQuery;
		exports.useIsFetching = require_useIsFetching.useIsFetching;
		exports.useIsMutating = require_useMutationState.useIsMutating;
		exports.useIsRestoring = require_IsRestoringProvider.useIsRestoring;
		exports.useMutation = require_useMutation.useMutation;
		exports.useMutationState = require_useMutationState.useMutationState;
		exports.usePrefetchInfiniteQuery = require_usePrefetchInfiniteQuery.usePrefetchInfiniteQuery;
		exports.usePrefetchQuery = require_usePrefetchQuery.usePrefetchQuery;
		exports.useQueries = require_useQueries.useQueries;
		exports.useQuery = require_useQuery.useQuery;
		exports.useQueryClient = require_QueryClientProvider.useQueryClient;
		exports.useQueryErrorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary;
		exports.useSuspenseInfiniteQuery = require_useSuspenseInfiniteQuery.useSuspenseInfiniteQuery;
		exports.useSuspenseQueries = require_useSuspenseQueries.useSuspenseQueries;
		exports.useSuspenseQuery = require_useSuspenseQuery.useSuspenseQuery;
		var _tanstack_query_core = require("@tanstack/query-core");
		Object.keys(_tanstack_query_core).forEach(function(k) {
		if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
		enumerable: true,
		get: function() {
		return _tanstack_query_core[k];
		}
		});
		});

		// src/index.ts
		var index_exports = {};
		__export(index_exports, {
		HydrationBoundary: () => import_HydrationBoundary.HydrationBoundary,
		IsRestoringProvider: () => import_IsRestoringProvider.IsRestoringProvider,
		QueryClientContext: () => import_QueryClientProvider.QueryClientContext,
		QueryClientProvider: () => import_QueryClientProvider.QueryClientProvider,
		QueryErrorResetBoundary: () => import_QueryErrorResetBoundary.QueryErrorResetBoundary,
		infiniteQueryOptions: () => import_infiniteQueryOptions.infiniteQueryOptions,
		mutationOptions: () => import_mutationOptions.mutationOptions,
		queryOptions: () => import_queryOptions.queryOptions,
		useInfiniteQuery: () => import_useInfiniteQuery.useInfiniteQuery,
		useIsFetching: () => import_useIsFetching.useIsFetching,
		useIsMutating: () => import_useMutationState.useIsMutating,
		useIsRestoring: () => import_IsRestoringProvider.useIsRestoring,
		useMutation: () => import_useMutation.useMutation,
		useMutationState: () => import_useMutationState.useMutationState,
		usePrefetchInfiniteQuery: () => import_usePrefetchInfiniteQuery.usePrefetchInfiniteQuery,
		usePrefetchQuery: () => import_usePrefetchQuery.usePrefetchQuery,
		useQueries: () => import_useQueries.useQueries,
		useQuery: () => import_useQuery.useQuery,
		useQueryClient: () => import_QueryClientProvider.useQueryClient,
		useQueryErrorResetBoundary: () => import_QueryErrorResetBoundary.useQueryErrorResetBoundary,
		useSuspenseInfiniteQuery: () => import_useSuspenseInfiniteQuery.useSuspenseInfiniteQuery,
		useSuspenseQueries: () => import_useSuspenseQueries.useSuspenseQueries,
		useSuspenseQuery: () => import_useSuspenseQuery.useSuspenseQuery
		});
		module.exports = __toCommonJS(index_exports);
		__reExport(index_exports, require("@tanstack/query-core"), module.exports);
		__reExport(index_exports, require("./types.cjs"), module.exports);
		var import_useQueries = require("./useQueries.cjs");
		var import_useQuery = require("./useQuery.cjs");
		var import_useSuspenseQuery = require("./useSuspenseQuery.cjs");
		var import_useSuspenseInfiniteQuery = require("./useSuspenseInfiniteQuery.cjs");
		var import_useSuspenseQueries = require("./useSuspenseQueries.cjs");
		var import_usePrefetchQuery = require("./usePrefetchQuery.cjs");
		var import_usePrefetchInfiniteQuery = require("./usePrefetchInfiniteQuery.cjs");
		var import_queryOptions = require("./queryOptions.cjs");
		var import_infiniteQueryOptions = require("./infiniteQueryOptions.cjs");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var import_HydrationBoundary = require("./HydrationBoundary.cjs");
		var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		var import_useIsFetching = require("./useIsFetching.cjs");
		var import_useMutationState = require("./useMutationState.cjs");
		var import_useMutation = require("./useMutation.cjs");
		var import_mutationOptions = require("./mutationOptions.cjs");
		var import_useInfiniteQuery = require("./useInfiniteQuery.cjs");
		var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		HydrationBoundary,
		IsRestoringProvider,
		QueryClientContext,
		QueryClientProvider,
		QueryErrorResetBoundary,
		infiniteQueryOptions,
		mutationOptions,
		queryOptions,
		useInfiniteQuery,
		useIsFetching,
		useIsMutating,
		useIsRestoring,
		useMutation,
		useMutationState,
		usePrefetchInfiniteQuery,
		usePrefetchQuery,
		useQueries,
		useQuery,
		useQueryClient,
		useQueryErrorResetBoundary,
		useSuspenseInfiniteQuery,
		useSuspenseQueries,
		useSuspenseQuery,
		...require("@tanstack/query-core"),
		...require("./types.cjs")
		});
		//# sourceMappingURL=index.cjs.map

+1

-1

build/legacy/index.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,0BAAc,iCAHd;AAMA,0BAAc,wBANd;AAOA,wBAA2B;AAE3B,sBAAyB;AACzB,8BAAiC;AACjC,sCAAyC;AACzC,gCAAmC;AAKnC,8BAAiC;AACjC,sCAAyC;AACzC,0BAA6B;AAM7B,kCAAqC;AAMrC,iCAIO;AAGP,+BAAkC;AAQlC,qCAGO;AACP,2BAA8B;AAC9B,8BAAgD;AAChD,yBAA4B;AAC5B,6BAAgC;AAChC,8BAAiC;AACjC,iCAAoD;","names":[]}
		{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport type * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":""}

+21

-205

build/legacy/index.d.cts

		@@ -1,205 +0,21 @@
		export { useQueries } from './_tsup-dts-rollup.cjs';
		export { QueriesResults } from './_tsup-dts-rollup.cjs';
		export { QueriesOptions } from './_tsup-dts-rollup.cjs';
		export { useQuery } from './_tsup-dts-rollup.cjs';
		export { useSuspenseQuery } from './_tsup-dts-rollup.cjs';
		export { useSuspenseInfiniteQuery } from './_tsup-dts-rollup.cjs';
		export { useSuspenseQueries } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesResults } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesOptions } from './_tsup-dts-rollup.cjs';
		export { usePrefetchQuery } from './_tsup-dts-rollup.cjs';
		export { usePrefetchInfiniteQuery } from './_tsup-dts-rollup.cjs';
		export { queryOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenOptions } from './_tsup-dts-rollup.cjs';
		export { infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.cjs';
		export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.cjs';
		export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.cjs';
		export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryProps_alias_1 as QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { HydrationBoundary_alias_1 as HydrationBoundary } from './_tsup-dts-rollup.cjs';
		export { HydrationBoundaryProps_alias_1 as HydrationBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { QueryErrorClearResetFunction_alias_1 as QueryErrorClearResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorIsResetFunction_alias_1 as QueryErrorIsResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryFunction_alias_1 as QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetFunction_alias_1 as QueryErrorResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundary_alias_1 as QueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		export { useQueryErrorResetBoundary_alias_1 as useQueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		export { useIsFetching } from './_tsup-dts-rollup.cjs';
		export { useIsMutating } from './_tsup-dts-rollup.cjs';
		export { useMutationState } from './_tsup-dts-rollup.cjs';
		export { useMutation } from './_tsup-dts-rollup.cjs';
		export { mutationOptions } from './_tsup-dts-rollup.cjs';
		export { useInfiniteQuery } from './_tsup-dts-rollup.cjs';
		export { useIsRestoring_alias_1 as useIsRestoring } from './_tsup-dts-rollup.cjs';
		export { IsRestoringProvider_alias_1 as IsRestoringProvider } from './_tsup-dts-rollup.cjs';
		export { focusManager } from './_tsup-dts-rollup.cjs';
		export { environmentManager } from './_tsup-dts-rollup.cjs';
		export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.cjs';
		export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.cjs';
		export { dehydrate } from './_tsup-dts-rollup.cjs';
		export { hydrate } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserver } from './_tsup-dts-rollup.cjs';
		export { MutationCache } from './_tsup-dts-rollup.cjs';
		export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
		export { MutationObserver } from './_tsup-dts-rollup.cjs';
		export { defaultScheduler } from './_tsup-dts-rollup.cjs';
		export { notifyManager } from './_tsup-dts-rollup.cjs';
		export { onlineManager } from './_tsup-dts-rollup.cjs';
		export { QueriesObserver } from './_tsup-dts-rollup.cjs';
		export { QueryCache } from './_tsup-dts-rollup.cjs';
		export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
		export { QueryClient } from './_tsup-dts-rollup.cjs';
		export { QueryObserver } from './_tsup-dts-rollup.cjs';
		export { CancelledError } from './_tsup-dts-rollup.cjs';
		export { isCancelledError } from './_tsup-dts-rollup.cjs';
		export { timeoutManager } from './_tsup-dts-rollup.cjs';
		export { ManagedTimerId } from './_tsup-dts-rollup.cjs';
		export { TimeoutCallback } from './_tsup-dts-rollup.cjs';
		export { TimeoutProvider } from './_tsup-dts-rollup.cjs';
		export { hashKey } from './_tsup-dts-rollup.cjs';
		export { isServer } from './_tsup-dts-rollup.cjs';
		export { keepPreviousData } from './_tsup-dts-rollup.cjs';
		export { matchMutation } from './_tsup-dts-rollup.cjs';
		export { matchQuery } from './_tsup-dts-rollup.cjs';
		export { noop } from './_tsup-dts-rollup.cjs';
		export { partialMatchKey } from './_tsup-dts-rollup.cjs';
		export { replaceEqualDeep } from './_tsup-dts-rollup.cjs';
		export { shouldThrowError } from './_tsup-dts-rollup.cjs';
		export { skipToken } from './_tsup-dts-rollup.cjs';
		export { MutationFilters } from './_tsup-dts-rollup.cjs';
		export { QueryFilters } from './_tsup-dts-rollup.cjs';
		export { SkipToken } from './_tsup-dts-rollup.cjs';
		export { Updater } from './_tsup-dts-rollup.cjs';
		export { experimental_streamedQuery } from './_tsup-dts-rollup.cjs';
		export { DehydratedState } from './_tsup-dts-rollup.cjs';
		export { DehydrateOptions } from './_tsup-dts-rollup.cjs';
		export { HydrateOptions } from './_tsup-dts-rollup.cjs';
		export { Mutation } from './_tsup-dts-rollup.cjs';
		export { MutationState } from './_tsup-dts-rollup.cjs';
		export { QueriesObserverOptions } from './_tsup-dts-rollup.cjs';
		export { Query } from './_tsup-dts-rollup.cjs';
		export { QueryState } from './_tsup-dts-rollup.cjs';
		export { NonUndefinedGuard } from './_tsup-dts-rollup.cjs';
		export { DistributiveOmit } from './_tsup-dts-rollup.cjs';
		export { OmitKeyof } from './_tsup-dts-rollup.cjs';
		export { Override } from './_tsup-dts-rollup.cjs';
		export { Register } from './_tsup-dts-rollup.cjs';
		export { DefaultError } from './_tsup-dts-rollup.cjs';
		export { QueryKey } from './_tsup-dts-rollup.cjs';
		export { dataTagSymbol } from './_tsup-dts-rollup.cjs';
		export { dataTagErrorSymbol } from './_tsup-dts-rollup.cjs';
		export { unsetMarker } from './_tsup-dts-rollup.cjs';
		export { UnsetMarker } from './_tsup-dts-rollup.cjs';
		export { AnyDataTag } from './_tsup-dts-rollup.cjs';
		export { DataTag } from './_tsup-dts-rollup.cjs';
		export { InferDataFromTag } from './_tsup-dts-rollup.cjs';
		export { InferErrorFromTag } from './_tsup-dts-rollup.cjs';
		export { QueryFunction } from './_tsup-dts-rollup.cjs';
		export { StaleTime } from './_tsup-dts-rollup.cjs';
		export { StaleTimeFunction } from './_tsup-dts-rollup.cjs';
		export { QueryBooleanOption } from './_tsup-dts-rollup.cjs';
		export { QueryPersister } from './_tsup-dts-rollup.cjs';
		export { QueryFunctionContext } from './_tsup-dts-rollup.cjs';
		export { InitialDataFunction } from './_tsup-dts-rollup.cjs';
		export { PlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
		export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
		export { QueryKeyHashFunction } from './_tsup-dts-rollup.cjs';
		export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.cjs';
		export { GetNextPageParamFunction } from './_tsup-dts-rollup.cjs';
		export { InfiniteData } from './_tsup-dts-rollup.cjs';
		export { QueryMeta } from './_tsup-dts-rollup.cjs';
		export { NetworkMode } from './_tsup-dts-rollup.cjs';
		export { NotifyOnChangeProps } from './_tsup-dts-rollup.cjs';
		export { QueryOptions } from './_tsup-dts-rollup.cjs';
		export { InitialPageParam } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.cjs';
		export { ThrowOnError } from './_tsup-dts-rollup.cjs';
		export { QueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { WithRequired } from './_tsup-dts-rollup.cjs';
		export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { FetchQueryOptions } from './_tsup-dts-rollup.cjs';
		export { EnsureQueryDataOptions } from './_tsup-dts-rollup.cjs';
		export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.cjs';
		export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { ResultOptions } from './_tsup-dts-rollup.cjs';
		export { RefetchOptions } from './_tsup-dts-rollup.cjs';
		export { InvalidateQueryFilters } from './_tsup-dts-rollup.cjs';
		export { RefetchQueryFilters } from './_tsup-dts-rollup.cjs';
		export { InvalidateOptions } from './_tsup-dts-rollup.cjs';
		export { ResetOptions } from './_tsup-dts-rollup.cjs';
		export { FetchNextPageOptions } from './_tsup-dts-rollup.cjs';
		export { FetchPreviousPageOptions } from './_tsup-dts-rollup.cjs';
		export { QueryStatus } from './_tsup-dts-rollup.cjs';
		export { FetchStatus } from './_tsup-dts-rollup.cjs';
		export { QueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
		export { DefinedQueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
		export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { MutationKey } from './_tsup-dts-rollup.cjs';
		export { MutationStatus } from './_tsup-dts-rollup.cjs';
		export { MutationScope } from './_tsup-dts-rollup.cjs';
		export { MutationMeta } from './_tsup-dts-rollup.cjs';
		export { MutationFunctionContext } from './_tsup-dts-rollup.cjs';
		export { MutationFunction } from './_tsup-dts-rollup.cjs';
		export { MutationOptions } from './_tsup-dts-rollup.cjs';
		export { MutationObserverOptions } from './_tsup-dts-rollup.cjs';
		export { MutateOptions } from './_tsup-dts-rollup.cjs';
		export { MutateFunction } from './_tsup-dts-rollup.cjs';
		export { MutationObserverBaseResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverIdleResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverLoadingResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverErrorResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverSuccessResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverResult } from './_tsup-dts-rollup.cjs';
		export { QueryClientConfig } from './_tsup-dts-rollup.cjs';
		export { DefaultOptions } from './_tsup-dts-rollup.cjs';
		export { CancelOptions } from './_tsup-dts-rollup.cjs';
		export { SetDataOptions } from './_tsup-dts-rollup.cjs';
		export { NotifyEventType } from './_tsup-dts-rollup.cjs';
		export { NotifyEvent } from './_tsup-dts-rollup.cjs';
		export { AnyUseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UsePrefetchQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { AnyUseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutateFunction } from './_tsup-dts-rollup.cjs';
		export { UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
		export { UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
		export { UseMutationResult } from './_tsup-dts-rollup.cjs';
		import { HydrationBoundary, HydrationBoundaryProps } from "./HydrationBoundary.cjs";
		import { IsRestoringProvider, useIsRestoring } from "./IsRestoringProvider.cjs";
		import { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient } from "./QueryClientProvider.cjs";
		import { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetFunction, useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.cjs";
		import { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
		import { QueriesOptions, QueriesResults, useQueries } from "./useQueries.cjs";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions } from "./queryOptions.cjs";
		import { useQuery } from "./useQuery.cjs";
		import { useSuspenseQuery } from "./useSuspenseQuery.cjs";
		import { useSuspenseInfiniteQuery } from "./useSuspenseInfiniteQuery.cjs";
		import { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries } from "./useSuspenseQueries.cjs";
		import { usePrefetchQuery } from "./usePrefetchQuery.cjs";
		import { usePrefetchInfiniteQuery } from "./usePrefetchInfiniteQuery.cjs";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions } from "./infiniteQueryOptions.cjs";
		import { useIsFetching } from "./useIsFetching.cjs";
		import { useIsMutating, useMutationState } from "./useMutationState.cjs";
		import { useMutation } from "./useMutation.cjs";
		import { mutationOptions } from "./mutationOptions.cjs";
		import { useInfiniteQuery } from "./useInfiniteQuery.cjs";
		export * from "@tanstack/query-core";
		export { type AnyUseBaseQueryOptions, type AnyUseInfiniteQueryOptions, type AnyUseMutationOptions, type AnyUseQueryOptions, type AnyUseSuspenseInfiniteQueryOptions, type AnyUseSuspenseQueryOptions, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, HydrationBoundary, type HydrationBoundaryProps, IsRestoringProvider, type QueriesOptions, type QueriesResults, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryErrorClearResetFunction, type QueryErrorIsResetFunction, QueryErrorResetBoundary, type QueryErrorResetBoundaryFunction, type QueryErrorResetBoundaryProps, type QueryErrorResetFunction, type SuspenseQueriesOptions, type SuspenseQueriesResults, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UnusedSkipTokenInfiniteOptions, type UnusedSkipTokenOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UsePrefetchInfiniteQueryOptions, type UsePrefetchQueryOptions, type UseQueryOptions, type UseQueryResult, type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryOptions, type UseSuspenseQueryResult, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };

+21

-205

build/legacy/index.d.ts

		@@ -1,205 +0,21 @@
		export { useQueries } from './_tsup-dts-rollup.js';
		export { QueriesResults } from './_tsup-dts-rollup.js';
		export { QueriesOptions } from './_tsup-dts-rollup.js';
		export { useQuery } from './_tsup-dts-rollup.js';
		export { useSuspenseQuery } from './_tsup-dts-rollup.js';
		export { useSuspenseInfiniteQuery } from './_tsup-dts-rollup.js';
		export { useSuspenseQueries } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesResults } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesOptions } from './_tsup-dts-rollup.js';
		export { usePrefetchQuery } from './_tsup-dts-rollup.js';
		export { usePrefetchInfiniteQuery } from './_tsup-dts-rollup.js';
		export { queryOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenOptions } from './_tsup-dts-rollup.js';
		export { infiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.js';
		export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.js';
		export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.js';
		export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.js';
		export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryProps_alias_1 as QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.js';
		export { HydrationBoundary_alias_1 as HydrationBoundary } from './_tsup-dts-rollup.js';
		export { HydrationBoundaryProps_alias_1 as HydrationBoundaryProps } from './_tsup-dts-rollup.js';
		export { QueryErrorClearResetFunction_alias_1 as QueryErrorClearResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorIsResetFunction_alias_1 as QueryErrorIsResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryFunction_alias_1 as QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetFunction_alias_1 as QueryErrorResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundary_alias_1 as QueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		export { useQueryErrorResetBoundary_alias_1 as useQueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		export { useIsFetching } from './_tsup-dts-rollup.js';
		export { useIsMutating } from './_tsup-dts-rollup.js';
		export { useMutationState } from './_tsup-dts-rollup.js';
		export { useMutation } from './_tsup-dts-rollup.js';
		export { mutationOptions } from './_tsup-dts-rollup.js';
		export { useInfiniteQuery } from './_tsup-dts-rollup.js';
		export { useIsRestoring_alias_1 as useIsRestoring } from './_tsup-dts-rollup.js';
		export { IsRestoringProvider_alias_1 as IsRestoringProvider } from './_tsup-dts-rollup.js';
		export { focusManager } from './_tsup-dts-rollup.js';
		export { environmentManager } from './_tsup-dts-rollup.js';
		export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.js';
		export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.js';
		export { dehydrate } from './_tsup-dts-rollup.js';
		export { hydrate } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserver } from './_tsup-dts-rollup.js';
		export { MutationCache } from './_tsup-dts-rollup.js';
		export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.js';
		export { MutationObserver } from './_tsup-dts-rollup.js';
		export { defaultScheduler } from './_tsup-dts-rollup.js';
		export { notifyManager } from './_tsup-dts-rollup.js';
		export { onlineManager } from './_tsup-dts-rollup.js';
		export { QueriesObserver } from './_tsup-dts-rollup.js';
		export { QueryCache } from './_tsup-dts-rollup.js';
		export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.js';
		export { QueryClient } from './_tsup-dts-rollup.js';
		export { QueryObserver } from './_tsup-dts-rollup.js';
		export { CancelledError } from './_tsup-dts-rollup.js';
		export { isCancelledError } from './_tsup-dts-rollup.js';
		export { timeoutManager } from './_tsup-dts-rollup.js';
		export { ManagedTimerId } from './_tsup-dts-rollup.js';
		export { TimeoutCallback } from './_tsup-dts-rollup.js';
		export { TimeoutProvider } from './_tsup-dts-rollup.js';
		export { hashKey } from './_tsup-dts-rollup.js';
		export { isServer } from './_tsup-dts-rollup.js';
		export { keepPreviousData } from './_tsup-dts-rollup.js';
		export { matchMutation } from './_tsup-dts-rollup.js';
		export { matchQuery } from './_tsup-dts-rollup.js';
		export { noop } from './_tsup-dts-rollup.js';
		export { partialMatchKey } from './_tsup-dts-rollup.js';
		export { replaceEqualDeep } from './_tsup-dts-rollup.js';
		export { shouldThrowError } from './_tsup-dts-rollup.js';
		export { skipToken } from './_tsup-dts-rollup.js';
		export { MutationFilters } from './_tsup-dts-rollup.js';
		export { QueryFilters } from './_tsup-dts-rollup.js';
		export { SkipToken } from './_tsup-dts-rollup.js';
		export { Updater } from './_tsup-dts-rollup.js';
		export { experimental_streamedQuery } from './_tsup-dts-rollup.js';
		export { DehydratedState } from './_tsup-dts-rollup.js';
		export { DehydrateOptions } from './_tsup-dts-rollup.js';
		export { HydrateOptions } from './_tsup-dts-rollup.js';
		export { Mutation } from './_tsup-dts-rollup.js';
		export { MutationState } from './_tsup-dts-rollup.js';
		export { QueriesObserverOptions } from './_tsup-dts-rollup.js';
		export { Query } from './_tsup-dts-rollup.js';
		export { QueryState } from './_tsup-dts-rollup.js';
		export { NonUndefinedGuard } from './_tsup-dts-rollup.js';
		export { DistributiveOmit } from './_tsup-dts-rollup.js';
		export { OmitKeyof } from './_tsup-dts-rollup.js';
		export { Override } from './_tsup-dts-rollup.js';
		export { Register } from './_tsup-dts-rollup.js';
		export { DefaultError } from './_tsup-dts-rollup.js';
		export { QueryKey } from './_tsup-dts-rollup.js';
		export { dataTagSymbol } from './_tsup-dts-rollup.js';
		export { dataTagErrorSymbol } from './_tsup-dts-rollup.js';
		export { unsetMarker } from './_tsup-dts-rollup.js';
		export { UnsetMarker } from './_tsup-dts-rollup.js';
		export { AnyDataTag } from './_tsup-dts-rollup.js';
		export { DataTag } from './_tsup-dts-rollup.js';
		export { InferDataFromTag } from './_tsup-dts-rollup.js';
		export { InferErrorFromTag } from './_tsup-dts-rollup.js';
		export { QueryFunction } from './_tsup-dts-rollup.js';
		export { StaleTime } from './_tsup-dts-rollup.js';
		export { StaleTimeFunction } from './_tsup-dts-rollup.js';
		export { QueryBooleanOption } from './_tsup-dts-rollup.js';
		export { QueryPersister } from './_tsup-dts-rollup.js';
		export { QueryFunctionContext } from './_tsup-dts-rollup.js';
		export { InitialDataFunction } from './_tsup-dts-rollup.js';
		export { PlaceholderDataFunction } from './_tsup-dts-rollup.js';
		export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.js';
		export { QueryKeyHashFunction } from './_tsup-dts-rollup.js';
		export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.js';
		export { GetNextPageParamFunction } from './_tsup-dts-rollup.js';
		export { InfiniteData } from './_tsup-dts-rollup.js';
		export { QueryMeta } from './_tsup-dts-rollup.js';
		export { NetworkMode } from './_tsup-dts-rollup.js';
		export { NotifyOnChangeProps } from './_tsup-dts-rollup.js';
		export { QueryOptions } from './_tsup-dts-rollup.js';
		export { InitialPageParam } from './_tsup-dts-rollup.js';
		export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.js';
		export { ThrowOnError } from './_tsup-dts-rollup.js';
		export { QueryObserverOptions } from './_tsup-dts-rollup.js';
		export { WithRequired } from './_tsup-dts-rollup.js';
		export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
		export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
		export { FetchQueryOptions } from './_tsup-dts-rollup.js';
		export { EnsureQueryDataOptions } from './_tsup-dts-rollup.js';
		export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.js';
		export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { ResultOptions } from './_tsup-dts-rollup.js';
		export { RefetchOptions } from './_tsup-dts-rollup.js';
		export { InvalidateQueryFilters } from './_tsup-dts-rollup.js';
		export { RefetchQueryFilters } from './_tsup-dts-rollup.js';
		export { InvalidateOptions } from './_tsup-dts-rollup.js';
		export { ResetOptions } from './_tsup-dts-rollup.js';
		export { FetchNextPageOptions } from './_tsup-dts-rollup.js';
		export { FetchPreviousPageOptions } from './_tsup-dts-rollup.js';
		export { QueryStatus } from './_tsup-dts-rollup.js';
		export { FetchStatus } from './_tsup-dts-rollup.js';
		export { QueryObserverBaseResult } from './_tsup-dts-rollup.js';
		export { QueryObserverPendingResult } from './_tsup-dts-rollup.js';
		export { QueryObserverLoadingResult } from './_tsup-dts-rollup.js';
		export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
		export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
		export { QueryObserverSuccessResult } from './_tsup-dts-rollup.js';
		export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
		export { DefinedQueryObserverResult } from './_tsup-dts-rollup.js';
		export { QueryObserverResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
		export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
		export { MutationKey } from './_tsup-dts-rollup.js';
		export { MutationStatus } from './_tsup-dts-rollup.js';
		export { MutationScope } from './_tsup-dts-rollup.js';
		export { MutationMeta } from './_tsup-dts-rollup.js';
		export { MutationFunctionContext } from './_tsup-dts-rollup.js';
		export { MutationFunction } from './_tsup-dts-rollup.js';
		export { MutationOptions } from './_tsup-dts-rollup.js';
		export { MutationObserverOptions } from './_tsup-dts-rollup.js';
		export { MutateOptions } from './_tsup-dts-rollup.js';
		export { MutateFunction } from './_tsup-dts-rollup.js';
		export { MutationObserverBaseResult } from './_tsup-dts-rollup.js';
		export { MutationObserverIdleResult } from './_tsup-dts-rollup.js';
		export { MutationObserverLoadingResult } from './_tsup-dts-rollup.js';
		export { MutationObserverErrorResult } from './_tsup-dts-rollup.js';
		export { MutationObserverSuccessResult } from './_tsup-dts-rollup.js';
		export { MutationObserverResult } from './_tsup-dts-rollup.js';
		export { QueryClientConfig } from './_tsup-dts-rollup.js';
		export { DefaultOptions } from './_tsup-dts-rollup.js';
		export { CancelOptions } from './_tsup-dts-rollup.js';
		export { SetDataOptions } from './_tsup-dts-rollup.js';
		export { NotifyEventType } from './_tsup-dts-rollup.js';
		export { NotifyEvent } from './_tsup-dts-rollup.js';
		export { AnyUseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UsePrefetchQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryResult } from './_tsup-dts-rollup.js';
		export { UseQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseQueryResult } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { AnyUseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutateFunction } from './_tsup-dts-rollup.js';
		export { UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
		export { UseBaseMutationResult } from './_tsup-dts-rollup.js';
		export { UseMutationResult } from './_tsup-dts-rollup.js';
		import { HydrationBoundary, HydrationBoundaryProps } from "./HydrationBoundary.js";
		import { IsRestoringProvider, useIsRestoring } from "./IsRestoringProvider.js";
		import { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient } from "./QueryClientProvider.js";
		import { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetFunction, useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
		import { QueriesOptions, QueriesResults, useQueries } from "./useQueries.js";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions } from "./queryOptions.js";
		import { useQuery } from "./useQuery.js";
		import { useSuspenseQuery } from "./useSuspenseQuery.js";
		import { useSuspenseInfiniteQuery } from "./useSuspenseInfiniteQuery.js";
		import { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries } from "./useSuspenseQueries.js";
		import { usePrefetchQuery } from "./usePrefetchQuery.js";
		import { usePrefetchInfiniteQuery } from "./usePrefetchInfiniteQuery.js";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions } from "./infiniteQueryOptions.js";
		import { useIsFetching } from "./useIsFetching.js";
		import { useIsMutating, useMutationState } from "./useMutationState.js";
		import { useMutation } from "./useMutation.js";
		import { mutationOptions } from "./mutationOptions.js";
		import { useInfiniteQuery } from "./useInfiniteQuery.js";
		export * from "@tanstack/query-core";
		export { type AnyUseBaseQueryOptions, type AnyUseInfiniteQueryOptions, type AnyUseMutationOptions, type AnyUseQueryOptions, type AnyUseSuspenseInfiniteQueryOptions, type AnyUseSuspenseQueryOptions, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, HydrationBoundary, type HydrationBoundaryProps, IsRestoringProvider, type QueriesOptions, type QueriesResults, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryErrorClearResetFunction, type QueryErrorIsResetFunction, QueryErrorResetBoundary, type QueryErrorResetBoundaryFunction, type QueryErrorResetBoundaryProps, type QueryErrorResetFunction, type SuspenseQueriesOptions, type SuspenseQueriesResults, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UnusedSkipTokenInfiniteOptions, type UnusedSkipTokenOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UsePrefetchInfiniteQueryOptions, type UsePrefetchQueryOptions, type UseQueryOptions, type UseQueryResult, type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryOptions, type UseSuspenseQueryResult, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };

+10

-39

build/legacy/index.js

		@@ -1,4 +0,5 @@
		// src/index.ts
		export * from "@tanstack/query-core";
		export * from "./types.js";
		import { QueryClientContext, QueryClientProvider, useQueryClient } from "./QueryClientProvider.js";
		import { HydrationBoundary } from "./HydrationBoundary.js";
		import { IsRestoringProvider, useIsRestoring } from "./IsRestoringProvider.js";
		import { QueryErrorResetBoundary, useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import { useQueries } from "./useQueries.js";
		@@ -13,12 +14,2 @@ import { useQuery } from "./useQuery.js";
		import { infiniteQueryOptions } from "./infiniteQueryOptions.js";
		import {
		QueryClientContext,
		QueryClientProvider,
		useQueryClient
		} from "./QueryClientProvider.js";
		import { HydrationBoundary } from "./HydrationBoundary.js";
		import {
		QueryErrorResetBoundary,
		useQueryErrorResetBoundary
		} from "./QueryErrorResetBoundary.js";
		import { useIsFetching } from "./useIsFetching.js";
		@@ -29,28 +20,8 @@ import { useIsMutating, useMutationState } from "./useMutationState.js";
		import { useInfiniteQuery } from "./useInfiniteQuery.js";
		import { useIsRestoring, IsRestoringProvider } from "./IsRestoringProvider.js";
		export {
		HydrationBoundary,
		IsRestoringProvider,
		QueryClientContext,
		QueryClientProvider,
		QueryErrorResetBoundary,
		infiniteQueryOptions,
		mutationOptions,
		queryOptions,
		useInfiniteQuery,
		useIsFetching,
		useIsMutating,
		useIsRestoring,
		useMutation,
		useMutationState,
		usePrefetchInfiniteQuery,
		usePrefetchQuery,
		useQueries,
		useQuery,
		useQueryClient,
		useQueryErrorResetBoundary,
		useSuspenseInfiniteQuery,
		useSuspenseQueries,
		useSuspenseQuery
		};
		export * from "@tanstack/query-core";
		//#region src/index.ts
		/* istanbul ignore file */
		//#endregion
		export { HydrationBoundary, IsRestoringProvider, QueryClientContext, QueryClientProvider, QueryErrorResetBoundary, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };

		//# sourceMappingURL=index.js.map

+1

-1

build/legacy/index.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":";AAGA,cAAc;AAGd,cAAc;AACd,SAAS,kBAAkB;AAE3B,SAAS,gBAAgB;AACzB,SAAS,wBAAwB;AACjC,SAAS,gCAAgC;AACzC,SAAS,0BAA0B;AAKnC,SAAS,wBAAwB;AACjC,SAAS,gCAAgC;AACzC,SAAS,oBAAoB;AAM7B,SAAS,4BAA4B;AAMrC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP,SAAS,yBAAyB;AAQlC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B,SAAS,eAAe,wBAAwB;AAChD,SAAS,mBAAmB;AAC5B,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;AACjC,SAAS,gBAAgB,2BAA2B;","names":[]}
		{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport type * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":""}

+6

-30

build/legacy/infiniteQueryOptions.cjs

		@@ -1,33 +0,9 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/infiniteQueryOptions.ts
		var infiniteQueryOptions_exports = {};
		__export(infiniteQueryOptions_exports, {
		infiniteQueryOptions: () => infiniteQueryOptions
		});
		module.exports = __toCommonJS(infiniteQueryOptions_exports);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/infiniteQueryOptions.ts
		function infiniteQueryOptions(options) {
		return options;
		return options;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		infiniteQueryOptions
		});
		//#endregion
		exports.infiniteQueryOptions = infiniteQueryOptions;

		//# sourceMappingURL=infiniteQueryOptions.cjs.map

+1

-1

build/legacy/infiniteQueryOptions.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkJO,SAAS,qBAAqB,SAAkB;AACrD,SAAO;AACT;","names":[]}
		{"version":3,"file":"infiniteQueryOptions.cjs","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;AA+IA,SAAgB,qBAAqB,SAAkB;CACrD,OAAO;AACT"}

+18

-4

build/legacy/infiniteQueryOptions.d.cts

		@@ -1,4 +0,18 @@
		export { infiniteQueryOptions_alias_1 as infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataInfiniteOptions_alias_1 as UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenInfiniteOptions_alias_1 as UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataInfiniteOptions_alias_1 as DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		import { UseInfiniteQueryOptions } from "./types.cjs";
		import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/infiniteQueryOptions.d.ts
		type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		//#endregion
		export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
		//# sourceMappingURL=infiniteQueryOptions.d.cts.map

+18

-4

build/legacy/infiniteQueryOptions.d.ts

		@@ -1,4 +0,18 @@
		export { infiniteQueryOptions_alias_1 as infiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataInfiniteOptions_alias_1 as UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenInfiniteOptions_alias_1 as UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataInfiniteOptions_alias_1 as DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		import { UseInfiniteQueryOptions } from "./types.js";
		import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/infiniteQueryOptions.d.ts
		type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		//#endregion
		export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
		//# sourceMappingURL=infiniteQueryOptions.d.ts.map

+5

-5

build/legacy/infiniteQueryOptions.js

		@@ -1,8 +0,8 @@
		// src/infiniteQueryOptions.ts
		//#region src/infiniteQueryOptions.ts
		function infiniteQueryOptions(options) {
		return options;
		return options;
		}
		export {
		infiniteQueryOptions
		};
		//#endregion
		export { infiniteQueryOptions };

		//# sourceMappingURL=infiniteQueryOptions.js.map

+1

-1

build/legacy/infiniteQueryOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AAkJO,SAAS,qBAAqB,SAAkB;AACrD,SAAO;AACT;","names":[]}
		{"version":3,"file":"infiniteQueryOptions.js","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AA+IA,SAAgB,qBAAqB,SAAkB;CACrD,OAAO;AACT"}

+11

-44

build/legacy/IsRestoringProvider.cjs

		@@ -1,47 +0,14 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		//#region src/IsRestoringProvider.ts
		const IsRestoringContext = react.createContext(false);
		const useIsRestoring = () => react.useContext(IsRestoringContext);
		const IsRestoringProvider = IsRestoringContext.Provider;
		//#endregion
		exports.IsRestoringProvider = IsRestoringProvider;
		exports.useIsRestoring = useIsRestoring;

		// src/IsRestoringProvider.ts
		var IsRestoringProvider_exports = {};
		__export(IsRestoringProvider_exports, {
		IsRestoringProvider: () => IsRestoringProvider,
		useIsRestoring: () => useIsRestoring
		});
		module.exports = __toCommonJS(IsRestoringProvider_exports);
		var React = __toESM(require("react"), 1);
		var IsRestoringContext = React.createContext(false);
		var useIsRestoring = () => React.useContext(IsRestoringContext);
		var IsRestoringProvider = IsRestoringContext.Provider;
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		IsRestoringProvider,
		useIsRestoring
		});
		//# sourceMappingURL=IsRestoringProvider.cjs.map

+1

-1

build/legacy/IsRestoringProvider.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,IAAM,qBAA2B,oBAAc,KAAK;AAE7C,IAAM,iBAAiB,MAAY,iBAAW,kBAAkB;AAChE,IAAM,sBAAsB,mBAAmB;","names":[]}
		{"version":3,"file":"IsRestoringProvider.cjs","names":["React"],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;;;;AAGA,MAAM,qBAAqBA,MAAM,cAAc,KAAK;AAEpD,MAAa,uBAAuBA,MAAM,WAAW,kBAAkB;AACvE,MAAa,sBAAsB,mBAAmB"}

+7

-2

build/legacy/IsRestoringProvider.d.cts

		@@ -1,2 +0,7 @@
		export { useIsRestoring } from './_tsup-dts-rollup.cjs';
		export { IsRestoringProvider } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		//#region src/IsRestoringProvider.d.ts
		declare const useIsRestoring: () => boolean;
		declare const IsRestoringProvider: React.Provider<boolean>;
		//#endregion
		export { IsRestoringProvider, useIsRestoring };
		//# sourceMappingURL=IsRestoringProvider.d.cts.map

+7

-2

build/legacy/IsRestoringProvider.d.ts

		@@ -1,2 +0,7 @@
		export { useIsRestoring } from './_tsup-dts-rollup.js';
		export { IsRestoringProvider } from './_tsup-dts-rollup.js';
		import * as React from "react";
		//#region src/IsRestoringProvider.d.ts
		declare const useIsRestoring: () => boolean;
		declare const IsRestoringProvider: React.Provider<boolean>;
		//#endregion
		export { IsRestoringProvider, useIsRestoring };
		//# sourceMappingURL=IsRestoringProvider.d.ts.map

+7

-9

build/legacy/IsRestoringProvider.js

		"use client";
		import * as React from "react";
		//#region src/IsRestoringProvider.ts
		const IsRestoringContext = React.createContext(false);
		const useIsRestoring = () => React.useContext(IsRestoringContext);
		const IsRestoringProvider = IsRestoringContext.Provider;
		//#endregion
		export { IsRestoringProvider, useIsRestoring };

		// src/IsRestoringProvider.ts
		import * as React from "react";
		var IsRestoringContext = React.createContext(false);
		var useIsRestoring = () => React.useContext(IsRestoringContext);
		var IsRestoringProvider = IsRestoringContext.Provider;
		export {
		IsRestoringProvider,
		useIsRestoring
		};
		//# sourceMappingURL=IsRestoringProvider.js.map

+1

-1

build/legacy/IsRestoringProvider.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,IAAM,qBAA2B,oBAAc,KAAK;AAE7C,IAAM,iBAAiB,MAAY,iBAAW,kBAAkB;AAChE,IAAM,sBAAsB,mBAAmB;","names":[]}
		{"version":3,"file":"IsRestoringProvider.js","names":[],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;AAGA,MAAM,qBAAqB,MAAM,cAAc,KAAK;AAEpD,MAAa,uBAAuB,MAAM,WAAW,kBAAkB;AACvE,MAAa,sBAAsB,mBAAmB"}

+6

-30

build/legacy/mutationOptions.cjs

		@@ -1,33 +0,9 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/mutationOptions.ts
		var mutationOptions_exports = {};
		__export(mutationOptions_exports, {
		mutationOptions: () => mutationOptions
		});
		module.exports = __toCommonJS(mutationOptions_exports);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/mutationOptions.ts
		function mutationOptions(options) {
		return options;
		return options;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		mutationOptions
		});
		//#endregion
		exports.mutationOptions = mutationOptions;

		//# sourceMappingURL=mutationOptions.cjs.map

+1

-1

build/legacy/mutationOptions.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BO,SAAS,gBAMd,SACgE;AAChE,SAAO;AACT;","names":[]}
		{"version":3,"file":"mutationOptions.cjs","names":[],"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";;AA+BA,SAAgB,gBAMd,SACgE;CAChE,OAAO;AACT"}

+8

-1

build/legacy/mutationOptions.d.cts

		@@ -1,1 +0,8 @@
		export { mutationOptions_alias_1 as mutationOptions } from './_tsup-dts-rollup.cjs';
		import { UseMutationOptions } from "./types.cjs";
		import { DefaultError, WithRequired } from "@tanstack/query-core";
		//#region src/mutationOptions.d.ts
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		//#endregion
		export { mutationOptions };
		//# sourceMappingURL=mutationOptions.d.cts.map

+8

-1

build/legacy/mutationOptions.d.ts

		@@ -1,1 +0,8 @@
		export { mutationOptions_alias_1 as mutationOptions } from './_tsup-dts-rollup.js';
		import { UseMutationOptions } from "./types.js";
		import { DefaultError, WithRequired } from "@tanstack/query-core";
		//#region src/mutationOptions.d.ts
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		//#endregion
		export { mutationOptions };
		//# sourceMappingURL=mutationOptions.d.ts.map

+5

-5

build/legacy/mutationOptions.js

		@@ -1,8 +0,8 @@
		// src/mutationOptions.ts
		//#region src/mutationOptions.ts
		function mutationOptions(options) {
		return options;
		return options;
		}
		export {
		mutationOptions
		};
		//#endregion
		export { mutationOptions };

		//# sourceMappingURL=mutationOptions.js.map

+1

-1

build/legacy/mutationOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";AA+BO,SAAS,gBAMd,SACgE;AAChE,SAAO;AACT;","names":[]}
		{"version":3,"file":"mutationOptions.js","names":[],"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";AA+BA,SAAgB,gBAMd,SACgE;CAChE,OAAO;AACT"}

+27

-67

build/legacy/QueryClientProvider.cjs

		@@ -1,72 +0,32 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let react_jsx_runtime = require("react/jsx-runtime");
		//#region src/QueryClientProvider.tsx
		const QueryClientContext = react.createContext(void 0);
		const useQueryClient = (queryClient) => {
		const client = react.useContext(QueryClientContext);
		if (queryClient) return queryClient;
		if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
		return client;
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		const QueryClientProvider = ({ client, children }) => {
		react.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(QueryClientContext.Provider, {
		value: client,
		children
		});
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		//#endregion
		exports.QueryClientContext = QueryClientContext;
		exports.QueryClientProvider = QueryClientProvider;
		exports.useQueryClient = useQueryClient;

		// src/QueryClientProvider.tsx
		var QueryClientProvider_exports = {};
		__export(QueryClientProvider_exports, {
		QueryClientContext: () => QueryClientContext,
		QueryClientProvider: () => QueryClientProvider,
		useQueryClient: () => useQueryClient
		});
		module.exports = __toCommonJS(QueryClientProvider_exports);
		var React = __toESM(require("react"), 1);
		var import_jsx_runtime = require("react/jsx-runtime");
		var QueryClientContext = React.createContext(
		void 0
		);
		var useQueryClient = (queryClient) => {
		const client = React.useContext(QueryClientContext);
		if (queryClient) {
		return queryClient;
		}
		if (!client) {
		throw new Error("No QueryClient set, use QueryClientProvider to set one");
		}
		return client;
		};
		var QueryClientProvider = ({
		client,
		children
		}) => {
		React.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children });
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		QueryClientContext,
		QueryClientProvider,
		useQueryClient
		});
		//# sourceMappingURL=QueryClientProvider.cjs.map

+1

-1

build/legacy/QueryClientProvider.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAuCnB;AAnCG,IAAM,qBAA2B;AAAA,EACtC;AACF;AAEO,IAAM,iBAAiB,CAAC,gBAA8B;AAC3D,QAAM,SAAe,iBAAW,kBAAkB;AAElD,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,wDAAwD;AAAA,EAC1E;AAEA,SAAO;AACT;AAOO,IAAM,sBAAsB,CAAC;AAAA,EAClC;AAAA,EACA;AACF,MAAmD;AACjD,EAAM,gBAAU,MAAM;AACpB,WAAO,MAAM;AACb,WAAO,MAAM;AACX,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF,GAAG,CAAC,MAAM,CAAC;AAEX,SACE,4CAAC,mBAAmB,UAAnB,EAA4B,OAAO,QACjC,UACH;AAEJ;","names":[]}
		{"version":3,"file":"QueryClientProvider.cjs","names":["React"],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;;;;;AAKA,MAAa,qBAAqBA,MAAM,cACtC,KAAA,CACF;AAEA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,SAASA,MAAM,WAAW,kBAAkB;CAElD,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;AAOA,MAAa,uBAAuB,EAClC,QACA,eACiD;CACjD,MAAM,gBAAgB;EACpB,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,iBAAA,GAAA,kBAAA,IAAA,CAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}

+13

-4

build/legacy/QueryClientProvider.d.cts

		@@ -1,4 +0,13 @@
		export { QueryClientContext } from './_tsup-dts-rollup.cjs';
		export { useQueryClient } from './_tsup-dts-rollup.cjs';
		export { QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
		export { QueryClientProvider } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		import { QueryClient } from "@tanstack/query-core";
		//#region src/QueryClientProvider.d.ts
		declare const QueryClientContext: React.Context<QueryClient \| undefined>;
		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		type QueryClientProviderProps = {
		client: QueryClient;
		children?: React.ReactNode;
		};
		declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => React.JSX.Element;
		//#endregion
		export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
		//# sourceMappingURL=QueryClientProvider.d.cts.map

+13

-4

build/legacy/QueryClientProvider.d.ts

		@@ -1,4 +0,13 @@
		export { QueryClientContext } from './_tsup-dts-rollup.js';
		export { useQueryClient } from './_tsup-dts-rollup.js';
		export { QueryClientProviderProps } from './_tsup-dts-rollup.js';
		export { QueryClientProvider } from './_tsup-dts-rollup.js';
		import * as React from "react";
		import { QueryClient } from "@tanstack/query-core";
		//#region src/QueryClientProvider.d.ts
		declare const QueryClientContext: React.Context<QueryClient \| undefined>;
		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		type QueryClientProviderProps = {
		client: QueryClient;
		children?: React.ReactNode;
		};
		declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => React.JSX.Element;
		//#endregion
		export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
		//# sourceMappingURL=QueryClientProvider.d.ts.map

+21

-30

build/legacy/QueryClientProvider.js

		"use client";

		// src/QueryClientProvider.tsx
		import * as React from "react";
		import { jsx } from "react/jsx-runtime";
		var QueryClientContext = React.createContext(
		void 0
		);
		var useQueryClient = (queryClient) => {
		const client = React.useContext(QueryClientContext);
		if (queryClient) {
		return queryClient;
		}
		if (!client) {
		throw new Error("No QueryClient set, use QueryClientProvider to set one");
		}
		return client;
		//#region src/QueryClientProvider.tsx
		const QueryClientContext = React.createContext(void 0);
		const useQueryClient = (queryClient) => {
		const client = React.useContext(QueryClientContext);
		if (queryClient) return queryClient;
		if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
		return client;
		};
		var QueryClientProvider = ({
		client,
		children
		}) => {
		React.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ jsx(QueryClientContext.Provider, { value: client, children });
		const QueryClientProvider = ({ client, children }) => {
		React.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ jsx(QueryClientContext.Provider, {
		value: client,
		children
		});
		};
		export {
		QueryClientContext,
		QueryClientProvider,
		useQueryClient
		};
		//#endregion
		export { QueryClientContext, QueryClientProvider, useQueryClient };

		//# sourceMappingURL=QueryClientProvider.js.map

+1

-1

build/legacy/QueryClientProvider.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAuCnB;AAnCG,IAAM,qBAA2B;AAAA,EACtC;AACF;AAEO,IAAM,iBAAiB,CAAC,gBAA8B;AAC3D,QAAM,SAAe,iBAAW,kBAAkB;AAElD,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,wDAAwD;AAAA,EAC1E;AAEA,SAAO;AACT;AAOO,IAAM,sBAAsB,CAAC;AAAA,EAClC;AAAA,EACA;AACF,MAAmD;AACjD,EAAM,gBAAU,MAAM;AACpB,WAAO,MAAM;AACb,WAAO,MAAM;AACX,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF,GAAG,CAAC,MAAM,CAAC;AAEX,SACE,oBAAC,mBAAmB,UAAnB,EAA4B,OAAO,QACjC,UACH;AAEJ;","names":[]}
		{"version":3,"file":"QueryClientProvider.js","names":[],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,MAAM,cACtC,KAAA,CACF;AAEA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,SAAS,MAAM,WAAW,kBAAkB;CAElD,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;AAOA,MAAa,uBAAuB,EAClC,QACA,eACiD;CACjD,MAAM,gBAAgB;EACpB,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,oBAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}

+30

-62

build/legacy/QueryErrorResetBoundary.cjs

		@@ -1,67 +0,35 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/QueryErrorResetBoundary.tsx
		var QueryErrorResetBoundary_exports = {};
		__export(QueryErrorResetBoundary_exports, {
		QueryErrorResetBoundary: () => QueryErrorResetBoundary,
		useQueryErrorResetBoundary: () => useQueryErrorResetBoundary
		});
		module.exports = __toCommonJS(QueryErrorResetBoundary_exports);
		var React = __toESM(require("react"), 1);
		var import_jsx_runtime = require("react/jsx-runtime");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let react_jsx_runtime = require("react/jsx-runtime");
		//#region src/QueryErrorResetBoundary.tsx
		function createValue() {
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		}
		var QueryErrorResetBoundaryContext = React.createContext(createValue());
		var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
		var QueryErrorResetBoundary = ({
		children
		}) => {
		const [value] = React.useState(() => createValue());
		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === "function" ? children(value) : children });
		const QueryErrorResetBoundaryContext = react.createContext(createValue());
		const useQueryErrorResetBoundary = () => react.useContext(QueryErrorResetBoundaryContext);
		const QueryErrorResetBoundary = ({ children }) => {
		const [value] = react.useState(() => createValue());
		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(QueryErrorResetBoundaryContext.Provider, {
		value,
		children: typeof children === "function" ? children(value) : children
		});
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		QueryErrorResetBoundary,
		useQueryErrorResetBoundary
		});
		//#endregion
		exports.QueryErrorResetBoundary = QueryErrorResetBoundary;
		exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;

		//# sourceMappingURL=QueryErrorResetBoundary.cjs.map

+1

-1

build/legacy/QueryErrorResetBoundary.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAkDnB;AArCJ,SAAS,cAA4C;AACnD,MAAI,UAAU;AACd,SAAO;AAAA,IACL,YAAY,MAAM;AAChB,gBAAU;AAAA,IACZ;AAAA,IACA,OAAO,MAAM;AACX,gBAAU;AAAA,IACZ;AAAA,IACA,SAAS,MAAM;AACb,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,IAAM,iCAAuC,oBAAc,YAAY,CAAC;AAIjE,IAAM,6BAA6B,MAClC,iBAAW,8BAA8B;AAY1C,IAAM,0BAA0B,CAAC;AAAA,EACtC;AACF,MAAoC;AAClC,QAAM,CAAC,KAAK,IAAU,eAAS,MAAM,YAAY,CAAC;AAClD,SACE,4CAAC,+BAA+B,UAA/B,EAAwC,OACtC,iBAAO,aAAa,aAAa,SAAS,KAAK,IAAI,UACtD;AAEJ;","names":[]}
		{"version":3,"file":"QueryErrorResetBoundary.cjs","names":["React"],"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;;;;;AAcA,SAAS,cAA4C;CACnD,IAAI,UAAU;CACd,OAAO;EACL,kBAAkB;GAChB,UAAU;EACZ;EACA,aAAa;GACX,UAAU;EACZ;EACA,eAAe;GACb,OAAO;EACT;CACF;AACF;AAEA,MAAM,iCAAiCA,MAAM,cAAc,YAAY,CAAC;AAIxE,MAAa,mCACXA,MAAM,WAAW,8BAA8B;AAYjD,MAAa,2BAA2B,EACtC,eACkC;CAClC,MAAM,CAAC,SAASA,MAAM,eAAe,YAAY,CAAC;CAClD,OACE,iBAAA,GAAA,kBAAA,IAAA,CAAC,+BAA+B,UAAhC;EAAgD;EAC7C,UAAA,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;CACb,CAAA;AAE7C"}

+19

-8

build/legacy/QueryErrorResetBoundary.d.cts

		@@ -1,8 +0,19 @@
		export { QueryErrorResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorIsResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorClearResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryValue } from './_tsup-dts-rollup.cjs';
		export { useQueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		//#region src/QueryErrorResetBoundary.d.ts
		type QueryErrorResetFunction = () => void;
		type QueryErrorIsResetFunction = () => boolean;
		type QueryErrorClearResetFunction = () => void;
		interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}
		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React.ReactNode;
		interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React.ReactNode;
		}
		declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("react/jsx-runtime").JSX.Element;
		//#endregion
		export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
		//# sourceMappingURL=QueryErrorResetBoundary.d.cts.map

+19

-8

build/legacy/QueryErrorResetBoundary.d.ts

		@@ -1,8 +0,19 @@
		export { QueryErrorResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorIsResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorClearResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryValue } from './_tsup-dts-rollup.js';
		export { useQueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		import * as React from "react";
		//#region src/QueryErrorResetBoundary.d.ts
		type QueryErrorResetFunction = () => void;
		type QueryErrorIsResetFunction = () => boolean;
		type QueryErrorClearResetFunction = () => void;
		interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}
		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React.ReactNode;
		interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React.ReactNode;
		}
		declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("react/jsx-runtime").JSX.Element;
		//#endregion
		export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
		//# sourceMappingURL=QueryErrorResetBoundary.d.ts.map

+24

-25

build/legacy/QueryErrorResetBoundary.js

		"use client";

		// src/QueryErrorResetBoundary.tsx
		import * as React from "react";
		import { jsx } from "react/jsx-runtime";
		//#region src/QueryErrorResetBoundary.tsx
		function createValue() {
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		}
		var QueryErrorResetBoundaryContext = React.createContext(createValue());
		var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
		var QueryErrorResetBoundary = ({
		children
		}) => {
		const [value] = React.useState(() => createValue());
		return /* @__PURE__ */ jsx(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === "function" ? children(value) : children });
		const QueryErrorResetBoundaryContext = React.createContext(createValue());
		const useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
		const QueryErrorResetBoundary = ({ children }) => {
		const [value] = React.useState(() => createValue());
		return /* @__PURE__ */ jsx(QueryErrorResetBoundaryContext.Provider, {
		value,
		children: typeof children === "function" ? children(value) : children
		});
		};
		export {
		QueryErrorResetBoundary,
		useQueryErrorResetBoundary
		};
		//#endregion
		export { QueryErrorResetBoundary, useQueryErrorResetBoundary };

		//# sourceMappingURL=QueryErrorResetBoundary.js.map

+1

-1

build/legacy/QueryErrorResetBoundary.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAkDnB;AArCJ,SAAS,cAA4C;AACnD,MAAI,UAAU;AACd,SAAO;AAAA,IACL,YAAY,MAAM;AAChB,gBAAU;AAAA,IACZ;AAAA,IACA,OAAO,MAAM;AACX,gBAAU;AAAA,IACZ;AAAA,IACA,SAAS,MAAM;AACb,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,IAAM,iCAAuC,oBAAc,YAAY,CAAC;AAIjE,IAAM,6BAA6B,MAClC,iBAAW,8BAA8B;AAY1C,IAAM,0BAA0B,CAAC;AAAA,EACtC;AACF,MAAoC;AAClC,QAAM,CAAC,KAAK,IAAU,eAAS,MAAM,YAAY,CAAC;AAClD,SACE,oBAAC,+BAA+B,UAA/B,EAAwC,OACtC,iBAAO,aAAa,aAAa,SAAS,KAAK,IAAI,UACtD;AAEJ;","names":[]}
		{"version":3,"file":"QueryErrorResetBoundary.js","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;;AAcA,SAAS,cAA4C;CACnD,IAAI,UAAU;CACd,OAAO;EACL,kBAAkB;GAChB,UAAU;EACZ;EACA,aAAa;GACX,UAAU;EACZ;EACA,eAAe;GACb,OAAO;EACT;CACF;AACF;AAEA,MAAM,iCAAiC,MAAM,cAAc,YAAY,CAAC;AAIxE,MAAa,mCACX,MAAM,WAAW,8BAA8B;AAYjD,MAAa,2BAA2B,EACtC,eACkC;CAClC,MAAM,CAAC,SAAS,MAAM,eAAe,YAAY,CAAC;CAClD,OACE,oBAAC,+BAA+B,UAAhC;EAAgD;EAC7C,UAAA,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;CACb,CAAA;AAE7C"}

+6

-30

build/legacy/queryOptions.cjs

		@@ -1,33 +0,9 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/queryOptions.ts
		var queryOptions_exports = {};
		__export(queryOptions_exports, {
		queryOptions: () => queryOptions
		});
		module.exports = __toCommonJS(queryOptions_exports);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/queryOptions.ts
		function queryOptions(options) {
		return options;
		return options;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		queryOptions
		});
		//#endregion
		exports.queryOptions = queryOptions;

		//# sourceMappingURL=queryOptions.cjs.map

+1

-1

build/legacy/queryOptions.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoFO,SAAS,aAAa,SAAkB;AAC7C,SAAO;AACT;","names":[]}
		{"version":3,"file":"queryOptions.cjs","names":[],"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;AAiFA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}

+19

-4

build/legacy/queryOptions.d.cts

		@@ -1,4 +0,19 @@
		export { queryOptions_alias_1 as queryOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataOptions_alias_1 as UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenOptions_alias_1 as UnusedSkipTokenOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataOptions_alias_1 as DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		import { UseQueryOptions } from "./types.cjs";
		import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/queryOptions.d.ts
		type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		//#endregion
		export { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions };
		//# sourceMappingURL=queryOptions.d.cts.map

+19

-4

build/legacy/queryOptions.d.ts

		@@ -1,4 +0,19 @@
		export { queryOptions_alias_1 as queryOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataOptions_alias_1 as UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenOptions_alias_1 as UnusedSkipTokenOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataOptions_alias_1 as DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		import { UseQueryOptions } from "./types.js";
		import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/queryOptions.d.ts
		type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		//#endregion
		export { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions };
		//# sourceMappingURL=queryOptions.d.ts.map

+5

-5

build/legacy/queryOptions.js

		@@ -1,8 +0,8 @@
		// src/queryOptions.ts
		//#region src/queryOptions.ts
		function queryOptions(options) {
		return options;
		return options;
		}
		export {
		queryOptions
		};
		//#endregion
		export { queryOptions };

		//# sourceMappingURL=queryOptions.js.map

+1

-1

build/legacy/queryOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AAoFO,SAAS,aAAa,SAAkB;AAC7C,SAAO;AACT;","names":[]}
		{"version":3,"file":"queryOptions.js","names":[],"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AAiFA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}

+20

-55

build/legacy/suspense.cjs

		@@ -1,58 +0,23 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/suspense.ts
		const defaultThrowOnError = (_error, query) => query.state.data === void 0;
		const 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 __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		const shouldSuspend = (defaultedOptions, result) => (defaultedOptions === null \|\| defaultedOptions === void 0 ? void 0 : defaultedOptions.suspense) && result.isPending;
		const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
		errorResetBoundary.clearReset();
		});
		//#endregion
		exports.defaultThrowOnError = defaultThrowOnError;
		exports.ensureSuspenseTimers = ensureSuspenseTimers;
		exports.fetchOptimistic = fetchOptimistic;
		exports.shouldSuspend = shouldSuspend;

		// src/suspense.ts
		var suspense_exports = {};
		__export(suspense_exports, {
		defaultThrowOnError: () => defaultThrowOnError,
		ensureSuspenseTimers: () => ensureSuspenseTimers,
		fetchOptimistic: () => fetchOptimistic,
		shouldSuspend: () => shouldSuspend,
		willFetch: () => willFetch
		});
		module.exports = __toCommonJS(suspense_exports);
		var defaultThrowOnError = (_error, query) => query.state.data === void 0;
		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 == null ? void 0 : defaultedOptions.suspense) && result.isPending;
		var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
		errorResetBoundary.clearReset();
		});
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		defaultThrowOnError,
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend,
		willFetch
		});
		//# sourceMappingURL=suspense.cjs.map

+1

-1

build/legacy/suspense.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const willFetch = (\n result: QueryObserverResult<any, any>,\n isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,IAAM,sBAAsB,CAMjC,QACA,UACG,MAAM,MAAM,SAAS;AAEnB,IAAM,uBAAuB,CAClC,qBACG;AACH,MAAI,iBAAiB,UAAU;AAG7B,UAAM,uBAAuB;AAE7B,UAAM,QAAQ,CAAC,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;AAElE,UAAM,oBAAoB,iBAAiB;AAC3C,qBAAiB,YACf,OAAO,sBAAsB,aACzB,IAAI,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;AAE7B,QAAI,OAAO,iBAAiB,WAAW,UAAU;AAC/C,uBAAiB,SAAS,KAAK;AAAA,QAC7B,iBAAiB;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,YAAY,CACvB,QACA,gBACG,OAAO,aAAa,OAAO,cAAc,CAAC;AAExC,IAAM,gBAAgB,CAC3B,kBAGA,YACG,qDAAkB,aAAY,OAAO;AAEnC,IAAM,kBAAkB,CAO7B,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,EAAE,MAAM,MAAM;AACrD,qBAAmB,WAAW;AAChC,CAAC;","names":[]}
		{"version":3,"file":"suspense.cjs","names":[],"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";;AAUA,MAAa,uBAMX,QACA,UACG,MAAM,MAAM,SAAS,KAAA;AAE1B,MAAa,wBACX,qBACG;CACH,IAAI,iBAAiB,UAAU;EAG7B,MAAM,uBAAuB;EAE7B,MAAM,SAAS,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;EAElE,MAAM,oBAAoB,iBAAiB;EAC3C,iBAAiB,YACf,OAAO,sBAAsB,cACxB,GAAG,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;EAE7B,IAAI,OAAO,iBAAiB,WAAW,UACrC,iBAAiB,SAAS,KAAK,IAC7B,iBAAiB,QACjB,oBACF;CAEJ;AACF;AAEA,MAAa,iBACX,kBAGA,YAAA,qBAAA,QAAA,qBAAA,KAAA,IAAA,KAAA,IACG,iBAAkB,aAAY,OAAO;AAE1C,MAAa,mBAOX,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,CAAC,CAAC,YAAY;CACrD,mBAAmB,WAAW;AAChC,CAAC"}

+10

-5

build/legacy/suspense.d.cts

		@@ -1,5 +0,10 @@
		export { defaultThrowOnError } from './_tsup-dts-rollup.cjs';
		export { ensureSuspenseTimers } from './_tsup-dts-rollup.cjs';
		export { willFetch } from './_tsup-dts-rollup.cjs';
		export { shouldSuspend } from './_tsup-dts-rollup.cjs';
		export { fetchOptimistic } from './_tsup-dts-rollup.cjs';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.cjs";
		import { DefaultError, DefaultedQueryObserverOptions, Query, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/suspense.d.ts
		declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;
		declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;
		declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;
		declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;
		//#endregion
		export { defaultThrowOnError, ensureSuspenseTimers, fetchOptimistic, shouldSuspend };
		//# sourceMappingURL=suspense.d.cts.map

+10

-5

build/legacy/suspense.d.ts

		@@ -1,5 +0,10 @@
		export { defaultThrowOnError } from './_tsup-dts-rollup.js';
		export { ensureSuspenseTimers } from './_tsup-dts-rollup.js';
		export { willFetch } from './_tsup-dts-rollup.js';
		export { shouldSuspend } from './_tsup-dts-rollup.js';
		export { fetchOptimistic } from './_tsup-dts-rollup.js';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.js";
		import { DefaultError, DefaultedQueryObserverOptions, Query, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/suspense.d.ts
		declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;
		declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;
		declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;
		declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;
		//#endregion
		export { defaultThrowOnError, ensureSuspenseTimers, fetchOptimistic, shouldSuspend };
		//# sourceMappingURL=suspense.d.ts.map

+16

-26

build/legacy/suspense.js

		@@ -1,29 +0,19 @@
		// src/suspense.ts
		var defaultThrowOnError = (_error, query) => query.state.data === void 0;
		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
		);
		}
		}
		//#region src/suspense.ts
		const defaultThrowOnError = (_error, query) => query.state.data === void 0;
		const 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 == null ? void 0 : defaultedOptions.suspense) && result.isPending;
		var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
		errorResetBoundary.clearReset();
		const shouldSuspend = (defaultedOptions, result) => (defaultedOptions === null \|\| defaultedOptions === void 0 ? void 0 : defaultedOptions.suspense) && result.isPending;
		const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
		errorResetBoundary.clearReset();
		});
		export {
		defaultThrowOnError,
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend,
		willFetch
		};
		//#endregion
		export { defaultThrowOnError, ensureSuspenseTimers, fetchOptimistic, shouldSuspend };

		//# sourceMappingURL=suspense.js.map

+1

-1

build/legacy/suspense.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const willFetch = (\n result: QueryObserverResult<any, any>,\n isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";AAUO,IAAM,sBAAsB,CAMjC,QACA,UACG,MAAM,MAAM,SAAS;AAEnB,IAAM,uBAAuB,CAClC,qBACG;AACH,MAAI,iBAAiB,UAAU;AAG7B,UAAM,uBAAuB;AAE7B,UAAM,QAAQ,CAAC,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;AAElE,UAAM,oBAAoB,iBAAiB;AAC3C,qBAAiB,YACf,OAAO,sBAAsB,aACzB,IAAI,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;AAE7B,QAAI,OAAO,iBAAiB,WAAW,UAAU;AAC/C,uBAAiB,SAAS,KAAK;AAAA,QAC7B,iBAAiB;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,YAAY,CACvB,QACA,gBACG,OAAO,aAAa,OAAO,cAAc,CAAC;AAExC,IAAM,gBAAgB,CAC3B,kBAGA,YACG,qDAAkB,aAAY,OAAO;AAEnC,IAAM,kBAAkB,CAO7B,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,EAAE,MAAM,MAAM;AACrD,qBAAmB,WAAW;AAChC,CAAC;","names":[]}
		{"version":3,"file":"suspense.js","names":[],"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";AAUA,MAAa,uBAMX,QACA,UACG,MAAM,MAAM,SAAS,KAAA;AAE1B,MAAa,wBACX,qBACG;CACH,IAAI,iBAAiB,UAAU;EAG7B,MAAM,uBAAuB;EAE7B,MAAM,SAAS,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;EAElE,MAAM,oBAAoB,iBAAiB;EAC3C,iBAAiB,YACf,OAAO,sBAAsB,cACxB,GAAG,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;EAE7B,IAAI,OAAO,iBAAiB,WAAW,UACrC,iBAAiB,SAAS,KAAK,IAC7B,iBAAiB,QACjB,oBACF;CAEJ;AACF;AAEA,MAAa,iBACX,kBAGA,YAAA,qBAAA,QAAA,qBAAA,KAAA,IAAA,KAAA,IACG,iBAAkB,aAAY,OAAO;AAE1C,MAAa,mBAOX,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,CAAC,CAAC,YAAY;CACrD,mBAAmB,WAAW;AAChC,CAAC"}

+3

-17

build/legacy/types.cjs

		@@ -1,19 +0,5 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		//#region src/types.ts
		/* istanbul ignore file */
		//#endregion

		// src/types.ts
		var types_exports = {};
		module.exports = __toCommonJS(types_exports);
		//# sourceMappingURL=types.cjs.map

+1

-1

build/legacy/types.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file /\n\nimport type {\n DefaultError,\n DefinedInfiniteQueryObserverResult,\n DefinedQueryObserverResult,\n DistributiveOmit,\n FetchQueryOptions,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n MutateFunction,\n MutationObserverOptions,\n MutationObserverResult,\n OmitKeyof,\n Override,\n QueryKey,\n QueryObserverOptions,\n QueryObserverResult,\n SkipToken,\n} from '@tanstack/query-core'\n\nexport type AnyUseBaseQueryOptions = UseBaseQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseBaseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n /\n subscribed?: boolean\n}\n\nexport interface UsePrefetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> {\n queryFn?: Exclude<\n FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>\nexport interface UseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n 'suspense'\n> {}\n\nexport type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<\n any,\n any,\n any,\n any\n>\nexport interface UseSuspenseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'suspense'\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n */\n subscribed?: boolean\n}\n\nexport type AnyUseSuspenseInfiniteQueryOptions =\n UseSuspenseInfiniteQueryOptions<any, any, any, any, any>\nexport interface UseSuspenseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UseBaseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = QueryObserverResult<TData, TError>\n\nexport type UseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = UseBaseQueryResult<TData, TError>\n\nexport type UseSuspenseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DistributiveOmit<\n DefinedQueryObserverResult<TData, TError>,\n 'isPlaceholderData' \| 'promise'\n>\n\nexport type DefinedUseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedQueryObserverResult<TData, TError>\n\nexport type UseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = InfiniteQueryObserverResult<TData, TError>\n\nexport type DefinedUseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedInfiniteQueryObserverResult<TData, TError>\n\nexport type UseSuspenseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = OmitKeyof<\n DefinedInfiniteQueryObserverResult<TData, TError>,\n 'isPlaceholderData' \| 'promise'\n>\n\nexport type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>\nexport interface UseMutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends OmitKeyof<\n MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n '_defaulted'\n> {}\n\nexport type UseMutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n ...args: Parameters<\n MutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n) => void\n\nexport type UseMutateAsyncFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\nexport type UseBaseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = Override<\n MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n mutateAsync: UseMutateAsyncFunction<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >\n}\n\nexport type UseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
		{"version":3,"file":"types.cjs","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file /\n\nimport type {\n DefaultError,\n DefinedInfiniteQueryObserverResult,\n DefinedQueryObserverResult,\n DistributiveOmit,\n InfiniteData,\n InfiniteQueryExecuteOptions,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n MutateFunction,\n MutationObserverOptions,\n MutationObserverResult,\n OmitKeyof,\n Override,\n QueryExecuteOptions,\n QueryKey,\n QueryObserverOptions,\n QueryObserverResult,\n SkipToken,\n} from '@tanstack/query-core'\n\nexport type AnyUseBaseQueryOptions = UseBaseQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseBaseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n /\n subscribed?: boolean\n}\n\nexport type UsePrefetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = DistributiveOmit<\n QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n QueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UsePrefetchInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = DistributiveOmit<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>\nexport interface UseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n 'suspense'\n> {}\n\nexport type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<\n any,\n any,\n any,\n any\n>\nexport interface UseSuspenseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'suspense'\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n */\n subscribed?: boolean\n}\n\nexport type AnyUseSuspenseInfiniteQueryOptions =\n UseSuspenseInfiniteQueryOptions<any, any, any, any, any>\nexport interface UseSuspenseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UseBaseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = QueryObserverResult<TData, TError>\n\nexport type UseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = UseBaseQueryResult<TData, TError>\n\nexport type UseSuspenseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DistributiveOmit<\n DefinedQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type DefinedUseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedQueryObserverResult<TData, TError>\n\nexport type UseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = InfiniteQueryObserverResult<TData, TError>\n\nexport type DefinedUseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedInfiniteQueryObserverResult<TData, TError>\n\nexport type UseSuspenseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = OmitKeyof<\n DefinedInfiniteQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>\nexport interface UseMutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends OmitKeyof<\n MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n '_defaulted'\n> {}\n\nexport type UseMutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n ...args: Parameters<\n MutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n) => void\n\nexport type UseMutateAsyncFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\nexport type UseBaseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = Override<\n MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n mutateAsync: UseMutateAsyncFunction<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >\n}\n\nexport type UseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>\n"],"mappings":""}

+54

-24

build/legacy/types.d.cts

		@@ -1,24 +0,54 @@
		export { AnyUseBaseQueryOptions_alias_1 as AnyUseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryOptions_alias_1 as UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UsePrefetchQueryOptions_alias_1 as UsePrefetchQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseQueryOptions_alias_1 as AnyUseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseQueryOptions_alias_1 as UseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseQueryOptions_alias_1 as AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryOptions_alias_1 as UseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseInfiniteQueryOptions_alias_1 as AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryOptions_alias_1 as UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseInfiniteQueryOptions_alias_1 as AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryOptions_alias_1 as UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryResult_alias_1 as UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseQueryResult_alias_1 as UseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryResult_alias_1 as UseSuspenseQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseQueryResult_alias_1 as DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryResult_alias_1 as UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseInfiniteQueryResult_alias_1 as DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryResult_alias_1 as UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { AnyUseMutationOptions_alias_1 as AnyUseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutationOptions_alias_1 as UseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutateFunction_alias_1 as UseMutateFunction } from './_tsup-dts-rollup.cjs';
		export { UseMutateAsyncFunction_alias_1 as UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
		export { UseBaseMutationResult_alias_1 as UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
		export { UseMutationResult_alias_1 as UseMutationResult } from './_tsup-dts-rollup.cjs';
		import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, DistributiveOmit, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryExecuteOptions, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken } from "@tanstack/query-core";
		//#region src/types.d.ts
		type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>['queryFn'], SkipToken>;
		};
		type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = DistributiveOmit<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		};
		type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
		type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
		type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult };
		//# sourceMappingURL=types.d.cts.map

+54

-24

build/legacy/types.d.ts

		@@ -1,24 +0,54 @@
		export { AnyUseBaseQueryOptions_alias_1 as AnyUseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryOptions_alias_1 as UseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UsePrefetchQueryOptions_alias_1 as UsePrefetchQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseQueryOptions_alias_1 as AnyUseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseQueryOptions_alias_1 as UseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseQueryOptions_alias_1 as AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryOptions_alias_1 as UseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseInfiniteQueryOptions_alias_1 as AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryOptions_alias_1 as UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseInfiniteQueryOptions_alias_1 as AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryOptions_alias_1 as UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryResult_alias_1 as UseBaseQueryResult } from './_tsup-dts-rollup.js';
		export { UseQueryResult_alias_1 as UseQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryResult_alias_1 as UseSuspenseQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseQueryResult_alias_1 as DefinedUseQueryResult } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryResult_alias_1 as UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseInfiniteQueryResult_alias_1 as DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryResult_alias_1 as UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { AnyUseMutationOptions_alias_1 as AnyUseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutationOptions_alias_1 as UseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutateFunction_alias_1 as UseMutateFunction } from './_tsup-dts-rollup.js';
		export { UseMutateAsyncFunction_alias_1 as UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
		export { UseBaseMutationResult_alias_1 as UseBaseMutationResult } from './_tsup-dts-rollup.js';
		export { UseMutationResult_alias_1 as UseMutationResult } from './_tsup-dts-rollup.js';
		import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, DistributiveOmit, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryExecuteOptions, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken } from "@tanstack/query-core";
		//#region src/types.d.ts
		type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>['queryFn'], SkipToken>;
		};
		type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = DistributiveOmit<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		};
		type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
		type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
		type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult };
		//# sourceMappingURL=types.d.ts.map

+5

-0

build/legacy/types.js

		@@ -0,1 +1,6 @@
		//#region src/types.ts
		/* istanbul ignore file */
		//#endregion
		export {};

		//# sourceMappingURL=types.js.map

+1

-1

build/legacy/types.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
		{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file /\n\nimport type {\n DefaultError,\n DefinedInfiniteQueryObserverResult,\n DefinedQueryObserverResult,\n DistributiveOmit,\n InfiniteData,\n InfiniteQueryExecuteOptions,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n MutateFunction,\n MutationObserverOptions,\n MutationObserverResult,\n OmitKeyof,\n Override,\n QueryExecuteOptions,\n QueryKey,\n QueryObserverOptions,\n QueryObserverResult,\n SkipToken,\n} from '@tanstack/query-core'\n\nexport type AnyUseBaseQueryOptions = UseBaseQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseBaseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n /\n subscribed?: boolean\n}\n\nexport type UsePrefetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = DistributiveOmit<\n QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n QueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UsePrefetchInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = DistributiveOmit<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>\nexport interface UseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n 'suspense'\n> {}\n\nexport type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<\n any,\n any,\n any,\n any\n>\nexport interface UseSuspenseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'suspense'\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n */\n subscribed?: boolean\n}\n\nexport type AnyUseSuspenseInfiniteQueryOptions =\n UseSuspenseInfiniteQueryOptions<any, any, any, any, any>\nexport interface UseSuspenseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UseBaseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = QueryObserverResult<TData, TError>\n\nexport type UseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = UseBaseQueryResult<TData, TError>\n\nexport type UseSuspenseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DistributiveOmit<\n DefinedQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type DefinedUseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedQueryObserverResult<TData, TError>\n\nexport type UseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = InfiniteQueryObserverResult<TData, TError>\n\nexport type DefinedUseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedInfiniteQueryObserverResult<TData, TError>\n\nexport type UseSuspenseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = OmitKeyof<\n DefinedInfiniteQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>\nexport interface UseMutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends OmitKeyof<\n MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n '_defaulted'\n> {}\n\nexport type UseMutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n ...args: Parameters<\n MutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n) => void\n\nexport type UseMutateAsyncFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\nexport type UseBaseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = Override<\n MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n mutateAsync: UseMutateAsyncFunction<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >\n}\n\nexport type UseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>\n"],"mappings":""}

+50

-130

build/legacy/useBaseQuery.cjs

		@@ -1,134 +0,54 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useBaseQuery.ts
		var useBaseQuery_exports = {};
		__export(useBaseQuery_exports, {
		useBaseQuery: () => useBaseQuery
		});
		module.exports = __toCommonJS(useBaseQuery_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		var import_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		const require_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		const require_suspense = require("./suspense.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useBaseQuery.ts
		function useBaseQuery(options, Observer, queryClient) {
		var _a, _b, _c, _d;
		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 = (0, import_IsRestoringProvider.useIsRestoring)();
		const errorResetBoundary = (0, import_QueryErrorResetBoundary.useQueryErrorResetBoundary)();
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const defaultedOptions = client.defaultQueryOptions(options);
		(_b = (_a = client.getDefaultOptions().queries) == null ? void 0 : _a._experimental_beforeQuery) == null ? void 0 : _b.call(
		_a,
		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`
		);
		}
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		(0, import_suspense.ensureSuspenseTimers)(defaultedOptions);
		(0, import_errorBoundaryUtils.ensurePreventErrorBoundaryRetry)(defaultedOptions, errorResetBoundary, query);
		(0, import_errorBoundaryUtils.useClearResetErrorBoundary)(errorResetBoundary);
		const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
		const [observer] = React.useState(
		() => new Observer(
		client,
		defaultedOptions
		)
		);
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)) : import_query_core.noop;
		observer.updateResult();
		return unsubscribe;
		},
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		React.useEffect(() => {
		observer.setOptions(defaultedOptions);
		}, [defaultedOptions, observer]);
		if ((0, import_suspense.shouldSuspend)(defaultedOptions, result)) {
		throw (0, import_suspense.fetchOptimistic)(defaultedOptions, observer, errorResetBoundary);
		}
		if ((0, import_errorBoundaryUtils.getHasError)({
		result,
		errorResetBoundary,
		throwOnError: defaultedOptions.throwOnError,
		query,
		suspense: defaultedOptions.suspense
		})) {
		throw result.error;
		}
		;
		(_d = (_c = client.getDefaultOptions().queries) == null ? void 0 : _c._experimental_afterQuery) == null ? void 0 : _d.call(
		_c,
		defaultedOptions,
		result
		);
		if (defaultedOptions.experimental_prefetchInRender && !import_query_core.environmentManager.isServer() && (0, import_suspense.willFetch)(result, isRestoring)) {
		const promise = isNewCacheEntry ? (
		// Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
		(0, import_suspense.fetchOptimistic)(defaultedOptions, observer, errorResetBoundary)
		) : (
		// subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
		query == null ? void 0 : query.promise
		);
		promise == null ? void 0 : promise.catch(import_query_core.noop).finally(() => {
		observer.updateResult();
		});
		}
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		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 = require_IsRestoringProvider.useIsRestoring();
		const errorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary();
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const defaultedOptions = client.defaultQueryOptions(options);
		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`);
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		require_suspense.ensureSuspenseTimers(defaultedOptions);
		require_errorBoundaryUtils.ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
		require_errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = react.useState(() => new Observer(client, defaultedOptions));
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		react.useSyncExternalStore(react.useCallback((onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)) : _tanstack_query_core.noop;
		observer.updateResult();
		return unsubscribe;
		}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		react.useEffect(() => {
		observer.setOptions(defaultedOptions);
		}, [defaultedOptions, observer]);
		if (require_suspense.shouldSuspend(defaultedOptions, result)) throw require_suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
		if (require_errorBoundaryUtils.getHasError({
		result,
		errorResetBoundary,
		throwOnError: defaultedOptions.throwOnError,
		query,
		suspense: defaultedOptions.suspense
		})) throw result.error;
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useBaseQuery
		});
		//#endregion
		exports.useBaseQuery = useBaseQuery;

		//# sourceMappingURL=useBaseQuery.cjs.map

+1

-1

build/legacy/useBaseQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { environmentManager, noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n willFetch,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n ;(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(\n defaultedOptions,\n )\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n // this needs to be invoked before creating the Observer because that can create a cache entry\n const isNewCacheEntry = !client\n .getQueryCache()\n .get(defaultedOptions.queryHash)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n ;(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(\n defaultedOptions,\n result,\n )\n\n if (\n defaultedOptions.experimental_prefetchInRender &&\n !environmentManager.isServer() &&\n willFetch(result, isRestoring)\n ) {\n const promise = isNewCacheEntry\n ? // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted\n fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n : // subscribe to the \"cache promise\" so that we can finalize the currentThenable once data comes in\n query?.promise\n\n promise?.catch(noop).finally(() => {\n // `.updateResult()` will trigger `.#currentThenable` to finalize\n observer.updateResult()\n })\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAAwD;AACxD,iCAA+B;AAC/B,qCAA2C;AAC3C,gCAIO;AACP,iCAA+B;AAC/B,sBAKO;AASA,SAAS,aAOd,SAOA,UACA,aACoC;AA1CtC;AA2CE,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GAAG;AACzD,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,kBAAc,2CAAe;AACnC,QAAM,yBAAqB,2DAA2B;AACtD,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,mBAAmB,OAAO,oBAAoB,OAAO;AAC1D,GAAC,kBAAO,kBAAkB,EAAE,YAA3B,mBAA4C,8BAA5C;AAAA;AAAA,IACA;AAAA;AAGF,QAAM,QAAQ,OACX,cAAc,EACd,IAKC,iBAAiB,SAAS;AAE9B,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,CAAC,iBAAiB,SAAS;AAC7B,cAAQ;AAAA,QACN,IAAI,iBAAiB,SAAS;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,eAAe;AAG1C,mBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA;AAEN,4CAAqB,gBAAgB;AACrC,iEAAgC,kBAAkB,oBAAoB,KAAK;AAC3E,4DAA2B,kBAAkB;AAG7C,QAAM,kBAAkB,CAAC,OACtB,cAAc,EACd,IAAI,iBAAiB,SAAS;AAEjC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,SAAS,SAAS,oBAAoB,gBAAgB;AAE5D,QAAM,kBAAkB,CAAC,eAAe;AACxC,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBAAkB;AACjB,cAAM,cAAc,kBAChB,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC,IAC1D;AAIJ,iBAAS,aAAa;AAEtB,eAAO;AAAA,MACT;AAAA,MACA,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,gBAAgB;AAAA,EACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;AAG/B,UAAI,+BAAc,kBAAkB,MAAM,GAAG;AAC3C,cAAM,iCAAgB,kBAAkB,UAAU,kBAAkB;AAAA,EACtE;AAGA,UACE,uCAAY;AAAA,IACV;AAAA,IACA;AAAA,IACA,cAAc,iBAAiB;AAAA,IAC/B;AAAA,IACA,UAAU,iBAAiB;AAAA,EAC7B,CAAC,GACD;AACA,UAAM,OAAO;AAAA,EACf;AAEA;AAAC,GAAC,kBAAO,kBAAkB,EAAE,YAA3B,mBAA4C,6BAA5C;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAGF,MACE,iBAAiB,iCACjB,CAAC,qCAAmB,SAAS,SAC7B,2BAAU,QAAQ,WAAW,GAC7B;AACA,UAAM,UAAU;AAAA;AAAA,UAEZ,iCAAgB,kBAAkB,UAAU,kBAAkB;AAAA;AAAA;AAAA,MAE9D,+BAAO;AAAA;AAEX,uCAAS,MAAM,wBAAM,QAAQ,MAAM;AAEjC,eAAS,aAAa;AAAA,IACxB;AAAA,EACF;AAGA,SAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN;","names":[]}
		{"version":3,"file":"useBaseQuery.cjs","names":["useIsRestoring","useQueryErrorResetBoundary","useQueryClient","React","notifyManager","noop","shouldSuspend","fetchOptimistic","getHasError"],"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;;;;;;;;;;AAyBA,SAAgB,aAOd,SAOA,UACA,aACoC;CACpC,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GACtD,MAAM,IAAI,MACR,gSACF;CAAA;CAIJ,MAAM,cAAcA,4BAAAA,eAAe;CACnC,MAAM,qBAAqBC,gCAAAA,2BAA2B;CACtD,MAAM,SAASC,4BAAAA,eAAe,WAAW;CACzC,MAAM,mBAAmB,OAAO,oBAAoB,OAAO;CAE3D,MAAM,QAAQ,OACX,cAAc,CAAC,CACf,IAKC,iBAAiB,SAAS;CAE9B,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,CAAC,iBAAiB,SACpB,QAAQ,MACN,IAAI,iBAAiB,UAAU,mPACjC;CAAA;CAIJ,MAAM,aAAa,QAAQ,eAAe;CAG1C,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;CAEN,iBAAA,qBAAqB,gBAAgB;CACrC,2BAAA,gCAAgC,kBAAkB,oBAAoB,KAAK;CAC3E,2BAAA,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAYC,MAAM,eAErB,IAAI,SACF,QACA,gBACF,CACJ;CAGA,MAAM,SAAS,SAAS,oBAAoB,gBAAgB;CAE5D,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJA,MAAM,aACH,kBAAkB;EACjB,MAAM,cAAc,kBAChB,SAAS,UAAUC,qBAAAA,cAAc,WAAW,aAAa,CAAC,IAC1DC,qBAAAA;EAIJ,SAAS,aAAa;EAEtB,OAAO;CACT,GACA,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,gBAAgB;CACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;CAG/B,IAAIC,iBAAAA,cAAc,kBAAkB,MAAM,GACxC,MAAMC,iBAAAA,gBAAgB,kBAAkB,UAAU,kBAAkB;CAItE,IACEC,2BAAAA,YAAY;EACV;EACA;EACA,cAAc,iBAAiB;EAC/B;EACA,UAAU,iBAAiB;CAC7B,CAAC,GAED,MAAM,OAAO;CAIf,OAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN"}

+7

-1

build/legacy/useBaseQuery.d.cts

		@@ -1,1 +0,7 @@
		export { useBaseQuery } from './_tsup-dts-rollup.cjs';
		import { UseBaseQueryOptions } from "./types.cjs";
		import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/useBaseQuery.d.ts
		declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
		//#endregion
		export { useBaseQuery };
		//# sourceMappingURL=useBaseQuery.d.cts.map

+7

-1

build/legacy/useBaseQuery.d.ts

		@@ -1,1 +0,7 @@
		export { useBaseQuery } from './_tsup-dts-rollup.js';
		import { UseBaseQueryOptions } from "./types.js";
		import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/useBaseQuery.d.ts
		declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
		//#endregion
		export { useBaseQuery };
		//# sourceMappingURL=useBaseQuery.d.ts.map

+45

-103

build/legacy/useBaseQuery.js

		"use client";

		// src/useBaseQuery.ts
		import * as React from "react";
		import { environmentManager, noop, notifyManager } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		import { useIsRestoring } from "./IsRestoringProvider.js";
		import { useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		} from "./errorBoundaryUtils.js";
		import { useIsRestoring } from "./IsRestoringProvider.js";
		import {
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend,
		willFetch
		} from "./suspense.js";
		import { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary } from "./errorBoundaryUtils.js";
		import { ensureSuspenseTimers, fetchOptimistic, shouldSuspend } from "./suspense.js";
		import * as React from "react";
		import { noop, notifyManager } from "@tanstack/query-core";
		//#region src/useBaseQuery.ts
		function useBaseQuery(options, Observer, queryClient) {
		var _a, _b, _c, _d;
		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);
		(_b = (_a = client.getDefaultOptions().queries) == null ? void 0 : _a._experimental_beforeQuery) == null ? void 0 : _b.call(
		_a,
		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`
		);
		}
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		ensureSuspenseTimers(defaultedOptions);
		ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
		useClearResetErrorBoundary(errorResetBoundary);
		const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
		const [observer] = React.useState(
		() => new Observer(
		client,
		defaultedOptions
		)
		);
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
		observer.updateResult();
		return unsubscribe;
		},
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		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;
		}
		;
		(_d = (_c = client.getDefaultOptions().queries) == null ? void 0 : _c._experimental_afterQuery) == null ? void 0 : _d.call(
		_c,
		defaultedOptions,
		result
		);
		if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) {
		const promise = isNewCacheEntry ? (
		// Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
		fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
		) : (
		// subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
		query == null ? void 0 : query.promise
		);
		promise == null ? void 0 : promise.catch(noop).finally(() => {
		observer.updateResult();
		});
		}
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		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);
		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`);
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		ensureSuspenseTimers(defaultedOptions);
		ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
		useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = React.useState(() => new Observer(client, defaultedOptions));
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(React.useCallback((onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
		observer.updateResult();
		return unsubscribe;
		}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		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;
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		}
		export {
		useBaseQuery
		};
		//#endregion
		export { useBaseQuery };

		//# sourceMappingURL=useBaseQuery.js.map

+1

-1

build/legacy/useBaseQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { environmentManager, noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n willFetch,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n ;(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(\n defaultedOptions,\n )\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n // this needs to be invoked before creating the Observer because that can create a cache entry\n const isNewCacheEntry = !client\n .getQueryCache()\n .get(defaultedOptions.queryHash)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n ;(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(\n defaultedOptions,\n result,\n )\n\n if (\n defaultedOptions.experimental_prefetchInRender &&\n !environmentManager.isServer() &&\n willFetch(result, isRestoring)\n ) {\n const promise = isNewCacheEntry\n ? // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted\n fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n : // subscribe to the \"cache promise\" so that we can finalize the currentThenable once data comes in\n query?.promise\n\n promise?.catch(noop).finally(() => {\n // `.updateResult()` will trigger `.#currentThenable` to finalize\n observer.updateResult()\n })\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,SAAS,oBAAoB,MAAM,qBAAqB;AACxD,SAAS,sBAAsB;AAC/B,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAC/B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AASA,SAAS,aAOd,SAOA,UACA,aACoC;AA1CtC;AA2CE,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GAAG;AACzD,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,cAAc,eAAe;AACnC,QAAM,qBAAqB,2BAA2B;AACtD,QAAM,SAAS,eAAe,WAAW;AACzC,QAAM,mBAAmB,OAAO,oBAAoB,OAAO;AAC1D,GAAC,kBAAO,kBAAkB,EAAE,YAA3B,mBAA4C,8BAA5C;AAAA;AAAA,IACA;AAAA;AAGF,QAAM,QAAQ,OACX,cAAc,EACd,IAKC,iBAAiB,SAAS;AAE9B,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,CAAC,iBAAiB,SAAS;AAC7B,cAAQ;AAAA,QACN,IAAI,iBAAiB,SAAS;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,eAAe;AAG1C,mBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA;AAEN,uBAAqB,gBAAgB;AACrC,kCAAgC,kBAAkB,oBAAoB,KAAK;AAC3E,6BAA2B,kBAAkB;AAG7C,QAAM,kBAAkB,CAAC,OACtB,cAAc,EACd,IAAI,iBAAiB,SAAS;AAEjC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,SAAS,SAAS,oBAAoB,gBAAgB;AAE5D,QAAM,kBAAkB,CAAC,eAAe;AACxC,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBAAkB;AACjB,cAAM,cAAc,kBAChB,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D;AAIJ,iBAAS,aAAa;AAEtB,eAAO;AAAA,MACT;AAAA,MACA,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,gBAAgB;AAAA,EACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;AAG/B,MAAI,cAAc,kBAAkB,MAAM,GAAG;AAC3C,UAAM,gBAAgB,kBAAkB,UAAU,kBAAkB;AAAA,EACtE;AAGA,MACE,YAAY;AAAA,IACV;AAAA,IACA;AAAA,IACA,cAAc,iBAAiB;AAAA,IAC/B;AAAA,IACA,UAAU,iBAAiB;AAAA,EAC7B,CAAC,GACD;AACA,UAAM,OAAO;AAAA,EACf;AAEA;AAAC,GAAC,kBAAO,kBAAkB,EAAE,YAA3B,mBAA4C,6BAA5C;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAGF,MACE,iBAAiB,iCACjB,CAAC,mBAAmB,SAAS,KAC7B,UAAU,QAAQ,WAAW,GAC7B;AACA,UAAM,UAAU;AAAA;AAAA,MAEZ,gBAAgB,kBAAkB,UAAU,kBAAkB;AAAA;AAAA;AAAA,MAE9D,+BAAO;AAAA;AAEX,uCAAS,MAAM,MAAM,QAAQ,MAAM;AAEjC,eAAS,aAAa;AAAA,IACxB;AAAA,EACF;AAGA,SAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN;","names":[]}
		{"version":3,"file":"useBaseQuery.js","names":[],"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;;;;;;;AAyBA,SAAgB,aAOd,SAOA,UACA,aACoC;CACpC,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GACtD,MAAM,IAAI,MACR,gSACF;CAAA;CAIJ,MAAM,cAAc,eAAe;CACnC,MAAM,qBAAqB,2BAA2B;CACtD,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,mBAAmB,OAAO,oBAAoB,OAAO;CAE3D,MAAM,QAAQ,OACX,cAAc,CAAC,CACf,IAKC,iBAAiB,SAAS;CAE9B,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,CAAC,iBAAiB,SACpB,QAAQ,MACN,IAAI,iBAAiB,UAAU,mPACjC;CAAA;CAIJ,MAAM,aAAa,QAAQ,eAAe;CAG1C,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;CAEN,qBAAqB,gBAAgB;CACrC,gCAAgC,kBAAkB,oBAAoB,KAAK;CAC3E,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAY,MAAM,eAErB,IAAI,SACF,QACA,gBACF,CACJ;CAGA,MAAM,SAAS,SAAS,oBAAoB,gBAAgB;CAE5D,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJ,MAAM,aACH,kBAAkB;EACjB,MAAM,cAAc,kBAChB,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D;EAIJ,SAAS,aAAa;EAEtB,OAAO;CACT,GACA,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,gBAAgB;CACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;CAG/B,IAAI,cAAc,kBAAkB,MAAM,GACxC,MAAM,gBAAgB,kBAAkB,UAAU,kBAAkB;CAItE,IACE,YAAY;EACV;EACA;EACA,cAAc,iBAAiB;EAC/B;EACA,UAAU,iBAAiB;CAC7B,CAAC,GAED,MAAM,OAAO;CAIf,OAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN"}

+8

-36

build/legacy/useInfiniteQuery.cjs

		@@ -1,40 +0,12 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useInfiniteQuery.ts
		var useInfiniteQuery_exports = {};
		__export(useInfiniteQuery_exports, {
		useInfiniteQuery: () => useInfiniteQuery
		});
		module.exports = __toCommonJS(useInfiniteQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useInfiniteQuery.ts
		function useInfiniteQuery(options, queryClient) {
		return (0, import_useBaseQuery.useBaseQuery)(
		options,
		import_query_core.InfiniteQueryObserver,
		queryClient
		);
		return require_useBaseQuery.useBaseQuery(options, _tanstack_query_core.InfiniteQueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useInfiniteQuery
		});
		//#endregion
		exports.useInfiniteQuery = useInfiniteQuery;

		//# sourceMappingURL=useInfiniteQuery.cjs.map

+1

-1

build/legacy/useInfiniteQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAAsC;AACtC,0BAA6B;AAqEtB,SAAS,iBACd,SACA,aACA;AACA,aAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useInfiniteQuery.cjs","names":["useBaseQuery","InfiniteQueryObserver"],"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;;;AAuEA,SAAgB,iBACd,SACA,aACA;CACA,OAAOA,qBAAAA,aACL,SACAC,qBAAAA,uBACA,WACF;AACF"}

+10

-1

build/legacy/useInfiniteQuery.d.cts

		@@ -1,1 +0,10 @@
		export { useInfiniteQuery_alias_1 as useInfiniteQuery } from './_tsup-dts-rollup.cjs';
		import { DefinedUseInfiniteQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult } from "./types.cjs";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from "./infiniteQueryOptions.cjs";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useInfiniteQuery.d.ts
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useInfiniteQuery };
		//# sourceMappingURL=useInfiniteQuery.d.cts.map

+10

-1

build/legacy/useInfiniteQuery.d.ts

		@@ -1,1 +0,10 @@
		export { useInfiniteQuery_alias_1 as useInfiniteQuery } from './_tsup-dts-rollup.js';
		import { DefinedUseInfiniteQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult } from "./types.js";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from "./infiniteQueryOptions.js";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useInfiniteQuery.d.ts
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useInfiniteQuery };
		//# sourceMappingURL=useInfiniteQuery.d.ts.map

+6

-11

build/legacy/useInfiniteQuery.js

		"use client";

		// src/useInfiniteQuery.ts
		import { useBaseQuery } from "./useBaseQuery.js";
		import { InfiniteQueryObserver } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		//#region src/useInfiniteQuery.ts
		function useInfiniteQuery(options, queryClient) {
		return useBaseQuery(
		options,
		InfiniteQueryObserver,
		queryClient
		);
		return useBaseQuery(options, InfiniteQueryObserver, queryClient);
		}
		export {
		useInfiniteQuery
		};
		//#endregion
		export { useInfiniteQuery };

		//# sourceMappingURL=useInfiniteQuery.js.map

+1

-1

build/legacy/useInfiniteQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;AACA,SAAS,6BAA6B;AACtC,SAAS,oBAAoB;AAqEtB,SAAS,iBACd,SACA,aACA;AACA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useInfiniteQuery.js","names":[],"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;;AAuEA,SAAgB,iBACd,SACA,aACA;CACA,OAAO,aACL,SACA,uBACA,WACF;AACF"}

+13

-52

build/legacy/useIsFetching.cjs

		@@ -1,56 +0,17 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useIsFetching.ts
		var useIsFetching_exports = {};
		__export(useIsFetching_exports, {
		useIsFetching: () => useIsFetching
		});
		module.exports = __toCommonJS(useIsFetching_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useIsFetching.ts
		function useIsFetching(filters, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const queryCache = client.getQueryCache();
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => queryCache.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)),
		[queryCache]
		),
		() => client.isFetching(filters),
		() => client.isFetching(filters)
		);
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const queryCache = client.getQueryCache();
		return react.useSyncExternalStore(react.useCallback((onStoreChange) => queryCache.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useIsFetching
		});
		//#endregion
		exports.useIsFetching = useIsFetching;

		//# sourceMappingURL=useIsFetching.cjs.map

+1

-1

build/legacy/useIsFetching.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AACvB,wBAA8B;AAE9B,iCAA+B;AAGxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,aAAa,OAAO,cAAc;AAExC,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,WAAW,UAAU,gCAAc,WAAW,aAAa,CAAC;AAAA,MAC9D,CAAC,UAAU;AAAA,IACb;AAAA,IACA,MAAM,OAAO,WAAW,OAAO;AAAA,IAC/B,MAAM,OAAO,WAAW,OAAO;AAAA,EACjC;AACF;","names":[]}
		{"version":3,"file":"useIsFetching.cjs","names":["useQueryClient","React","notifyManager"],"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,MAAM,aAAa,OAAO,cAAc;CAExC,OAAOC,MAAM,qBACXA,MAAM,aACH,kBACC,WAAW,UAAUC,qBAAAA,cAAc,WAAW,aAAa,CAAC,GAC9D,CAAC,UAAU,CACb,SACM,OAAO,WAAW,OAAO,SACzB,OAAO,WAAW,OAAO,CACjC;AACF"}

+6

-1

build/legacy/useIsFetching.d.cts

		@@ -1,1 +0,6 @@
		export { useIsFetching_alias_1 as useIsFetching } from './_tsup-dts-rollup.cjs';
		import { QueryClient, QueryFilters } from "@tanstack/query-core";
		//#region src/useIsFetching.d.ts
		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		//#endregion
		export { useIsFetching };
		//# sourceMappingURL=useIsFetching.d.cts.map

+6

-1

build/legacy/useIsFetching.d.ts

		@@ -1,1 +0,6 @@
		export { useIsFetching_alias_1 as useIsFetching } from './_tsup-dts-rollup.js';
		import { QueryClient, QueryFilters } from "@tanstack/query-core";
		//#region src/useIsFetching.d.ts
		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		//#endregion
		export { useIsFetching };
		//# sourceMappingURL=useIsFetching.d.ts.map

+8

-16

build/legacy/useIsFetching.js

		"use client";

		// src/useIsFetching.ts
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import { notifyManager } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		//#region src/useIsFetching.ts
		function useIsFetching(filters, queryClient) {
		const client = useQueryClient(queryClient);
		const queryCache = client.getQueryCache();
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),
		[queryCache]
		),
		() => client.isFetching(filters),
		() => client.isFetching(filters)
		);
		const client = useQueryClient(queryClient);
		const queryCache = client.getQueryCache();
		return React.useSyncExternalStore(React.useCallback((onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
		}
		export {
		useIsFetching
		};
		//#endregion
		export { useIsFetching };

		//# sourceMappingURL=useIsFetching.js.map

+1

-1

build/legacy/useIsFetching.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AACvB,SAAS,qBAAqB;AAE9B,SAAS,sBAAsB;AAGxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,SAAS,eAAe,WAAW;AACzC,QAAM,aAAa,OAAO,cAAc;AAExC,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,WAAW,UAAU,cAAc,WAAW,aAAa,CAAC;AAAA,MAC9D,CAAC,UAAU;AAAA,IACb;AAAA,IACA,MAAM,OAAO,WAAW,OAAO;AAAA,IAC/B,MAAM,OAAO,WAAW,OAAO;AAAA,EACjC;AACF;","names":[]}
		{"version":3,"file":"useIsFetching.js","names":[],"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;;;AAOA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,aAAa,OAAO,cAAc;CAExC,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,WAAW,UAAU,cAAc,WAAW,aAAa,CAAC,GAC9D,CAAC,UAAU,CACb,SACM,OAAO,WAAW,OAAO,SACzB,OAAO,WAAW,OAAO,CACjC;AACF"}

+25

-70

build/legacy/useMutation.cjs

		@@ -1,74 +0,29 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useMutation.ts
		var useMutation_exports = {};
		__export(useMutation_exports, {
		useMutation: () => useMutation
		});
		module.exports = __toCommonJS(useMutation_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useMutation.ts
		function useMutation(options, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const [observer] = React.useState(
		() => new import_query_core.MutationObserver(
		client,
		options
		)
		);
		React.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)),
		[observer]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		const mutate = React.useCallback(
		(variables, mutateOptions) => {
		observer.mutate(variables, mutateOptions).catch(import_query_core.noop);
		},
		[observer]
		);
		if (result.error && (0, import_query_core.shouldThrowError)(observer.options.throwOnError, [result.error])) {
		throw result.error;
		}
		return { ...result, mutate, mutateAsync: result.mutate };
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const [observer] = react.useState(() => new _tanstack_query_core.MutationObserver(client, options));
		react.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = react.useSyncExternalStore(react.useCallback((onStoreChange) => observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		const mutate = react.useCallback((...args) => {
		observer.mutate(args[0], args[1]).catch(_tanstack_query_core.noop);
		}, [observer]);
		if (result.error && (0, _tanstack_query_core.shouldThrowError)(observer.options.throwOnError, [result.error])) throw result.error;
		return {
		...result,
		mutate,
		mutateAsync: result.mutate
		};
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useMutation
		});
		//#endregion
		exports.useMutation = useMutation;

		//# sourceMappingURL=useMutation.cjs.map

+1

-1

build/legacy/useMutation.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (variables, mutateOptions) => {\n observer.mutate(variables, mutateOptions).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AACvB,wBAKO;AACP,iCAA+B;AAUxB,SAAS,YAMd,SACA,aAC+D;AAC/D,QAAM,aAAS,2CAAe,WAAW;AAEzC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,OAAO;AAAA,EAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;AAEtB,QAAM,SAAe;AAAA,IACb;AAAA,MACJ,CAAC,kBACC,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC;AAAA,MAC5D,CAAC,QAAQ;AAAA,IACX;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,QAAM,SAAe;AAAA,IAGnB,CAAC,WAAW,kBAAkB;AAC5B,eAAS,OAAO,WAAW,aAAa,EAAE,MAAM,sBAAI;AAAA,IACtD;AAAA,IACA,CAAC,QAAQ;AAAA,EACX;AAEA,MACE,OAAO,aACP,oCAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAC9D;AACA,UAAM,OAAO;AAAA,EACf;AAEA,SAAO,EAAE,GAAG,QAAQ,QAAQ,aAAa,OAAO,OAAO;AACzD;","names":[]}
		{"version":3,"file":"useMutation.cjs","names":["useQueryClient","React","MutationObserver","notifyManager","noop","shouldThrowError"],"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (\n ...args: Parameters<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n ) => {\n observer.mutate(args[0] as TVariables, args[1]).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;;;;;;AAkBA,SAAgB,YAMd,SACA,aAC+D;CAC/D,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,MAAM,CAAC,YAAYC,MAAM,eAErB,IAAIC,qBAAAA,iBACF,QACA,OACF,CACJ;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,OAAO;CAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;CAEtB,MAAM,SAASD,MAAM,qBACnBA,MAAM,aACH,kBACC,SAAS,UAAUE,qBAAAA,cAAc,WAAW,aAAa,CAAC,GAC5D,CAAC,QAAQ,CACX,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,SAASF,MAAM,aAIjB,GAAG,SAGA;EACH,SAAS,OAAO,KAAK,IAAkB,KAAK,EAAE,CAAC,CAAC,MAAMG,qBAAAA,IAAI;CAC5D,GACA,CAAC,QAAQ,CACX;CAEA,IACE,OAAO,UAAA,GACPC,qBAAAA,iBAAAA,CAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAE9D,MAAM,OAAO;CAGf,OAAO;EAAE,GAAG;EAAQ;EAAQ,aAAa,OAAO;CAAO;AACzD"}

+7

-1

build/legacy/useMutation.d.cts

		@@ -1,1 +0,7 @@
		export { useMutation_alias_1 as useMutation } from './_tsup-dts-rollup.cjs';
		import { UseMutationOptions, UseMutationResult } from "./types.cjs";
		import { DefaultError, QueryClient } from "@tanstack/query-core";
		//#region src/useMutation.d.ts
		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { useMutation };
		//# sourceMappingURL=useMutation.d.cts.map

+7

-1

build/legacy/useMutation.d.ts

		@@ -1,1 +0,7 @@
		export { useMutation_alias_1 as useMutation } from './_tsup-dts-rollup.js';
		import { UseMutationOptions, UseMutationResult } from "./types.js";
		import { DefaultError, QueryClient } from "@tanstack/query-core";
		//#region src/useMutation.d.ts
		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { useMutation };
		//# sourceMappingURL=useMutation.d.ts.map

+21

-40

build/legacy/useMutation.js

		"use client";

		// src/useMutation.ts
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import {
		MutationObserver,
		noop,
		notifyManager,
		shouldThrowError
		} from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		import { MutationObserver, noop, notifyManager, shouldThrowError } from "@tanstack/query-core";
		//#region src/useMutation.ts
		function useMutation(options, queryClient) {
		const client = useQueryClient(queryClient);
		const [observer] = React.useState(
		() => new MutationObserver(
		client,
		options
		)
		);
		React.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
		[observer]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		const mutate = 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 };
		const client = useQueryClient(queryClient);
		const [observer] = React.useState(() => new MutationObserver(client, options));
		React.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = React.useSyncExternalStore(React.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		const mutate = React.useCallback((...args) => {
		observer.mutate(args[0], args[1]).catch(noop);
		}, [observer]);
		if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
		return {
		...result,
		mutate,
		mutateAsync: result.mutate
		};
		}
		export {
		useMutation
		};
		//#endregion
		export { useMutation };

		//# sourceMappingURL=useMutation.js.map

+1

-1

build/legacy/useMutation.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (variables, mutateOptions) => {\n observer.mutate(variables, mutateOptions).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AACvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAUxB,SAAS,YAMd,SACA,aAC+D;AAC/D,QAAM,SAAS,eAAe,WAAW;AAEzC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,OAAO;AAAA,EAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;AAEtB,QAAM,SAAe;AAAA,IACb;AAAA,MACJ,CAAC,kBACC,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC;AAAA,MAC5D,CAAC,QAAQ;AAAA,IACX;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,QAAM,SAAe;AAAA,IAGnB,CAAC,WAAW,kBAAkB;AAC5B,eAAS,OAAO,WAAW,aAAa,EAAE,MAAM,IAAI;AAAA,IACtD;AAAA,IACA,CAAC,QAAQ;AAAA,EACX;AAEA,MACE,OAAO,SACP,iBAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAC9D;AACA,UAAM,OAAO;AAAA,EACf;AAEA,SAAO,EAAE,GAAG,QAAQ,QAAQ,aAAa,OAAO,OAAO;AACzD;","names":[]}
		{"version":3,"file":"useMutation.js","names":[],"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (\n ...args: Parameters<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n ) => {\n observer.mutate(args[0] as TVariables, args[1]).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;;;AAkBA,SAAgB,YAMd,SACA,aAC+D;CAC/D,MAAM,SAAS,eAAe,WAAW;CAEzC,MAAM,CAAC,YAAY,MAAM,eAErB,IAAI,iBACF,QACA,OACF,CACJ;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,OAAO;CAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;CAEtB,MAAM,SAAS,MAAM,qBACnB,MAAM,aACH,kBACC,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,GAC5D,CAAC,QAAQ,CACX,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,SAAS,MAAM,aAIjB,GAAG,SAGA;EACH,SAAS,OAAO,KAAK,IAAkB,KAAK,EAAE,CAAC,CAAC,MAAM,IAAI;CAC5D,GACA,CAAC,QAAQ,CACX;CAEA,IACE,OAAO,SACP,iBAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAE9D,MAAM,OAAO;CAGf,OAAO;EAAE,GAAG;EAAQ;EAAQ,aAAa,OAAO;CAAO;AACzD"}

+31

-78

build/legacy/useMutationState.cjs

		@@ -1,86 +0,39 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useMutationState.ts
		var useMutationState_exports = {};
		__export(useMutationState_exports, {
		useIsMutating: () => useIsMutating,
		useMutationState: () => useMutationState
		});
		module.exports = __toCommonJS(useMutationState_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useMutationState.ts
		function useIsMutating(filters, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		return useMutationState(
		{ filters: { ...filters, status: "pending" } },
		client
		).length;
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		return useMutationState({ filters: {
		...filters,
		status: "pending"
		} }, client).length;
		}
		function getResult(mutationCache, options) {
		return mutationCache.findAll(options.filters).map(
		(mutation) => options.select ? options.select(mutation) : mutation.state
		);
		return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
		}
		function useMutationState(options = {}, queryClient) {
		const mutationCache = (0, import_QueryClientProvider.useQueryClient)(queryClient).getMutationCache();
		const optionsRef = React.useRef(options);
		const result = React.useRef(null);
		if (result.current === null) {
		result.current = getResult(mutationCache, options);
		}
		React.useEffect(() => {
		optionsRef.current = options;
		});
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = (0, import_query_core.replaceEqualDeep)(
		result.current,
		getResult(mutationCache, optionsRef.current)
		);
		if (result.current !== nextResult) {
		result.current = nextResult;
		import_query_core.notifyManager.schedule(onStoreChange);
		}
		}),
		[mutationCache]
		),
		() => result.current,
		() => result.current
		);
		const mutationCache = require_QueryClientProvider.useQueryClient(queryClient).getMutationCache();
		const optionsRef = react.useRef(options);
		const result = react.useRef(null);
		if (result.current === null) result.current = getResult(mutationCache, options);
		react.useEffect(() => {
		optionsRef.current = options;
		});
		return react.useSyncExternalStore(react.useCallback((onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = (0, _tanstack_query_core.replaceEqualDeep)(result.current, getResult(mutationCache, optionsRef.current));
		if (result.current !== nextResult) {
		result.current = nextResult;
		_tanstack_query_core.notifyManager.schedule(onStoreChange);
		}
		}), [mutationCache]), () => result.current, () => result.current);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useIsMutating,
		useMutationState
		});
		//#endregion
		exports.useIsMutating = useIsMutating;
		exports.useMutationState = useMutationState;

		//# sourceMappingURL=useMutationState.cjs.map

+1

-1

build/legacy/useMutationState.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationStateOptions<TResult = MutationState> = {\n filters?: MutationFilters\n select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult<TResult = MutationState>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select ? options.select(mutation) : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<TResult = MutationState>(\n options: MutationStateOptions<TResult> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAAgD;AAChD,iCAA+B;AASxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,aAAS,2CAAe,WAAW;AACzC,SAAO;AAAA,IACL,EAAE,SAAS,EAAE,GAAG,SAAS,QAAQ,UAAU,EAAE;AAAA,IAC7C;AAAA,EACF,EAAE;AACJ;AAOA,SAAS,UACP,eACA,SACgB;AAChB,SAAO,cACJ,QAAQ,QAAQ,OAAO,EACvB;AAAA,IACC,CAAC,aACE,QAAQ,SAAS,QAAQ,OAAO,QAAQ,IAAI,SAAS;AAAA,EAC1D;AACJ;AAEO,SAAS,iBACd,UAAyC,CAAC,GAC1C,aACgB;AAChB,QAAM,oBAAgB,2CAAe,WAAW,EAAE,iBAAiB;AACnE,QAAM,aAAmB,aAAO,OAAO;AACvC,QAAM,SAAe,aAAuB,IAAI;AAChD,MAAI,OAAO,YAAY,MAAM;AAC3B,WAAO,UAAU,UAAU,eAAe,OAAO;AAAA,EACnD;AAEA,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAED,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,cAAc,UAAU,MAAM;AAC5B,cAAM,iBAAa;AAAA,UACjB,OAAO;AAAA,UACP,UAAU,eAAe,WAAW,OAAO;AAAA,QAC7C;AACA,YAAI,OAAO,YAAY,YAAY;AACjC,iBAAO,UAAU;AACjB,0CAAc,SAAS,aAAa;AAAA,QACtC;AAAA,MACF,CAAC;AAAA,MACH,CAAC,aAAa;AAAA,IAChB;AAAA,IACA,MAAM,OAAO;AAAA,IACb,MAAM,OAAO;AAAA,EACf;AACF;","names":[]}
		{"version":3,"file":"useMutationState.cjs","names":["useQueryClient","React","replaceEqualDeep"],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;;;;AAaA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;AAEA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgBA,4BAAAA,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAaC,MAAM,OAAO,OAAO;CACvC,MAAM,SAASA,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAOA,MAAM,qBACXA,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,cAAA,GAAaC,qBAAAA,iBAAAA,CACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,qBAAA,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}

+12

-2

build/legacy/useMutationState.d.cts

		@@ -1,2 +0,12 @@
		export { useIsMutating_alias_1 as useIsMutating } from './_tsup-dts-rollup.cjs';
		export { useMutationState_alias_1 as useMutationState } from './_tsup-dts-rollup.cjs';
		import { Mutation, MutationFilters, MutationState, QueryClient } from "@tanstack/query-core";
		//#region src/useMutationState.d.ts
		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		type MutationTypeFromResult<TResult> = [TResult] extends [MutationState<infer TData, infer TError, infer TVariables, infer TOnMutateResult>] ? Mutation<TData, TError, TVariables, TOnMutateResult> : Mutation;
		type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>> = {
		filters?: MutationFilters;
		select?: (mutation: TMutation) => TResult;
		};
		declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
		//#endregion
		export { useIsMutating, useMutationState };
		//# sourceMappingURL=useMutationState.d.cts.map

+12

-2

build/legacy/useMutationState.d.ts

		@@ -1,2 +0,12 @@
		export { useIsMutating_alias_1 as useIsMutating } from './_tsup-dts-rollup.js';
		export { useMutationState_alias_1 as useMutationState } from './_tsup-dts-rollup.js';
		import { Mutation, MutationFilters, MutationState, QueryClient } from "@tanstack/query-core";
		//#region src/useMutationState.d.ts
		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		type MutationTypeFromResult<TResult> = [TResult] extends [MutationState<infer TData, infer TError, infer TVariables, infer TOnMutateResult>] ? Mutation<TData, TError, TVariables, TOnMutateResult> : Mutation;
		type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>> = {
		filters?: MutationFilters;
		select?: (mutation: TMutation) => TResult;
		};
		declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
		//#endregion
		export { useIsMutating, useMutationState };
		//# sourceMappingURL=useMutationState.d.ts.map

+25

-41

build/legacy/useMutationState.js

		"use client";

		// src/useMutationState.ts
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import { notifyManager, replaceEqualDeep } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		//#region src/useMutationState.ts
		function useIsMutating(filters, queryClient) {
		const client = useQueryClient(queryClient);
		return useMutationState(
		{ filters: { ...filters, status: "pending" } },
		client
		).length;
		const client = useQueryClient(queryClient);
		return useMutationState({ filters: {
		...filters,
		status: "pending"
		} }, client).length;
		}
		function getResult(mutationCache, options) {
		return mutationCache.findAll(options.filters).map(
		(mutation) => options.select ? options.select(mutation) : mutation.state
		);
		return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
		}
		function useMutationState(options = {}, queryClient) {
		const mutationCache = useQueryClient(queryClient).getMutationCache();
		const optionsRef = React.useRef(options);
		const result = React.useRef(null);
		if (result.current === null) {
		result.current = getResult(mutationCache, options);
		}
		React.useEffect(() => {
		optionsRef.current = options;
		});
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = replaceEqualDeep(
		result.current,
		getResult(mutationCache, optionsRef.current)
		);
		if (result.current !== nextResult) {
		result.current = nextResult;
		notifyManager.schedule(onStoreChange);
		}
		}),
		[mutationCache]
		),
		() => result.current,
		() => result.current
		);
		const mutationCache = useQueryClient(queryClient).getMutationCache();
		const optionsRef = React.useRef(options);
		const result = React.useRef(null);
		if (result.current === null) result.current = getResult(mutationCache, options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		return React.useSyncExternalStore(React.useCallback((onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = replaceEqualDeep(result.current, getResult(mutationCache, optionsRef.current));
		if (result.current !== nextResult) {
		result.current = nextResult;
		notifyManager.schedule(onStoreChange);
		}
		}), [mutationCache]), () => result.current, () => result.current);
		}
		export {
		useIsMutating,
		useMutationState
		};
		//#endregion
		export { useIsMutating, useMutationState };

		//# sourceMappingURL=useMutationState.js.map

+1

-1

build/legacy/useMutationState.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationStateOptions<TResult = MutationState> = {\n filters?: MutationFilters\n select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult<TResult = MutationState>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select ? options.select(mutation) : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<TResult = MutationState>(\n options: MutationStateOptions<TResult> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,SAAS,eAAe,wBAAwB;AAChD,SAAS,sBAAsB;AASxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,SAAS,eAAe,WAAW;AACzC,SAAO;AAAA,IACL,EAAE,SAAS,EAAE,GAAG,SAAS,QAAQ,UAAU,EAAE;AAAA,IAC7C;AAAA,EACF,EAAE;AACJ;AAOA,SAAS,UACP,eACA,SACgB;AAChB,SAAO,cACJ,QAAQ,QAAQ,OAAO,EACvB;AAAA,IACC,CAAC,aACE,QAAQ,SAAS,QAAQ,OAAO,QAAQ,IAAI,SAAS;AAAA,EAC1D;AACJ;AAEO,SAAS,iBACd,UAAyC,CAAC,GAC1C,aACgB;AAChB,QAAM,gBAAgB,eAAe,WAAW,EAAE,iBAAiB;AACnE,QAAM,aAAmB,aAAO,OAAO;AACvC,QAAM,SAAe,aAAuB,IAAI;AAChD,MAAI,OAAO,YAAY,MAAM;AAC3B,WAAO,UAAU,UAAU,eAAe,OAAO;AAAA,EACnD;AAEA,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAED,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,cAAc,UAAU,MAAM;AAC5B,cAAM,aAAa;AAAA,UACjB,OAAO;AAAA,UACP,UAAU,eAAe,WAAW,OAAO;AAAA,QAC7C;AACA,YAAI,OAAO,YAAY,YAAY;AACjC,iBAAO,UAAU;AACjB,wBAAc,SAAS,aAAa;AAAA,QACtC;AAAA,MACF,CAAC;AAAA,MACH,CAAC,aAAa;AAAA,IAChB;AAAA,IACA,MAAM,OAAO;AAAA,IACb,MAAM,OAAO;AAAA,EACf;AACF;","names":[]}
		{"version":3,"file":"useMutationState.js","names":[],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;AAaA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;AAEA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgB,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,SAAS,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,aAAa,iBACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}

+9

-34

build/legacy/usePrefetchInfiniteQuery.cjs

		@@ -1,37 +0,12 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/usePrefetchInfiniteQuery.tsx
		var usePrefetchInfiniteQuery_exports = {};
		__export(usePrefetchInfiniteQuery_exports, {
		usePrefetchInfiniteQuery: () => usePrefetchInfiniteQuery
		});
		module.exports = __toCommonJS(usePrefetchInfiniteQuery_exports);
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/usePrefetchInfiniteQuery.tsx
		function usePrefetchInfiniteQuery(options, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchInfiniteQuery(options);
		}
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(_tanstack_query_core.noop);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		usePrefetchInfiniteQuery
		});
		//#endregion
		exports.usePrefetchInfiniteQuery = usePrefetchInfiniteQuery;

		//# sourceMappingURL=usePrefetchInfiniteQuery.cjs.map

+1

-1

build/legacy/usePrefetchInfiniteQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type {\n DefaultError,\n FetchInfiniteQueryOptions,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchInfiniteQuery(options)\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA+B;AAQxB,SAAS,yBAOd,SAOA,aACA;AACA,QAAM,aAAS,2CAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,sBAAsB,OAAO;AAAA,EACtC;AACF;","names":[]}
		{"version":3,"file":"usePrefetchInfiniteQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UsePrefetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.infiniteQuery(options).catch(noop)\n }\n}\n"],"mappings":";;;;AAWA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEjD"}

+7

-1

build/legacy/usePrefetchInfiniteQuery.d.cts

		@@ -1,1 +0,7 @@
		export { usePrefetchInfiniteQuery_alias_1 as usePrefetchInfiniteQuery } from './_tsup-dts-rollup.cjs';
		import { UsePrefetchInfiniteQueryOptions } from "./types.cjs";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchInfiniteQuery.d.ts
		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchInfiniteQuery };
		//# sourceMappingURL=usePrefetchInfiniteQuery.d.cts.map

+7

-1

build/legacy/usePrefetchInfiniteQuery.d.ts

		@@ -1,1 +0,7 @@
		export { usePrefetchInfiniteQuery_alias_1 as usePrefetchInfiniteQuery } from './_tsup-dts-rollup.js';
		import { UsePrefetchInfiniteQueryOptions } from "./types.js";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchInfiniteQuery.d.ts
		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchInfiniteQuery };
		//# sourceMappingURL=usePrefetchInfiniteQuery.d.ts.map

+7

-8

build/legacy/usePrefetchInfiniteQuery.js

		@@ -1,12 +0,11 @@
		// src/usePrefetchInfiniteQuery.tsx
		import { useQueryClient } from "./QueryClientProvider.js";
		import { noop } from "@tanstack/query-core";
		//#region src/usePrefetchInfiniteQuery.tsx
		function usePrefetchInfiniteQuery(options, queryClient) {
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchInfiniteQuery(options);
		}
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(noop);
		}
		export {
		usePrefetchInfiniteQuery
		};
		//#endregion
		export { usePrefetchInfiniteQuery };

		//# sourceMappingURL=usePrefetchInfiniteQuery.js.map

+1

-1

build/legacy/usePrefetchInfiniteQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type {\n DefaultError,\n FetchInfiniteQueryOptions,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchInfiniteQuery(options)\n }\n}\n"],"mappings":";AAAA,SAAS,sBAAsB;AAQxB,SAAS,yBAOd,SAOA,aACA;AACA,QAAM,SAAS,eAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,sBAAsB,OAAO;AAAA,EACtC;AACF;","names":[]}
		{"version":3,"file":"usePrefetchInfiniteQuery.js","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UsePrefetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.infiniteQuery(options).catch(noop)\n }\n}\n"],"mappings":";;;AAWA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAM,IAAI;AAEjD"}

+9

-34

build/legacy/usePrefetchQuery.cjs

		@@ -1,37 +0,12 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/usePrefetchQuery.tsx
		var usePrefetchQuery_exports = {};
		__export(usePrefetchQuery_exports, {
		usePrefetchQuery: () => usePrefetchQuery
		});
		module.exports = __toCommonJS(usePrefetchQuery_exports);
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/usePrefetchQuery.tsx
		function usePrefetchQuery(options, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchQuery(options);
		}
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.query(options).catch(_tanstack_query_core.noop);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		usePrefetchQuery
		});
		//#endregion
		exports.usePrefetchQuery = usePrefetchQuery;

		//# sourceMappingURL=usePrefetchQuery.cjs.map

+1

-1

build/legacy/usePrefetchQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchQuery(options)\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA+B;AAIxB,SAAS,iBAMd,SACA,aACA;AACA,QAAM,aAAS,2CAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,cAAc,OAAO;AAAA,EAC9B;AACF;","names":[]}
		{"version":3,"file":"usePrefetchQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.query(options).catch(noop)\n }\n}\n"],"mappings":";;;;AAMA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEzC"}

+7

-1

build/legacy/usePrefetchQuery.d.cts

		@@ -1,1 +0,7 @@
		export { usePrefetchQuery_alias_1 as usePrefetchQuery } from './_tsup-dts-rollup.cjs';
		import { UsePrefetchQueryOptions } from "./types.cjs";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchQuery.d.ts
		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchQuery };
		//# sourceMappingURL=usePrefetchQuery.d.cts.map

+7

-1

build/legacy/usePrefetchQuery.d.ts

		@@ -1,1 +0,7 @@
		export { usePrefetchQuery_alias_1 as usePrefetchQuery } from './_tsup-dts-rollup.js';
		import { UsePrefetchQueryOptions } from "./types.js";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchQuery.d.ts
		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchQuery };
		//# sourceMappingURL=usePrefetchQuery.d.ts.map

+7

-8

build/legacy/usePrefetchQuery.js

		@@ -1,12 +0,11 @@
		// src/usePrefetchQuery.tsx
		import { useQueryClient } from "./QueryClientProvider.js";
		import { noop } from "@tanstack/query-core";
		//#region src/usePrefetchQuery.tsx
		function usePrefetchQuery(options, queryClient) {
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchQuery(options);
		}
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.query(options).catch(noop);
		}
		export {
		usePrefetchQuery
		};
		//#endregion
		export { usePrefetchQuery };

		//# sourceMappingURL=usePrefetchQuery.js.map

+1

-1

build/legacy/usePrefetchQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchQuery(options)\n }\n}\n"],"mappings":";AAAA,SAAS,sBAAsB;AAIxB,SAAS,iBAMd,SACA,aACA;AACA,QAAM,SAAS,eAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,cAAc,OAAO;AAAA,EAC9B;AACF;","names":[]}
		{"version":3,"file":"usePrefetchQuery.js","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.query(options).catch(noop)\n }\n}\n"],"mappings":";;;AAMA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAM,IAAI;AAEzC"}

+67

-125

build/legacy/useQueries.cjs

		@@ -1,128 +0,70 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		const require_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		const require_suspense = require("./suspense.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useQueries.ts
		function useQueries({ queries, ...options }, queryClient) {
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const isRestoring = require_IsRestoringProvider.useIsRestoring();
		const errorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary();
		const subscribed = options.subscribed !== false;
		const defaultedQueries = react.useMemo(() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(opts);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		return defaultedOptions;
		}), [
		queries,
		client,
		isRestoring,
		subscribed
		]);
		defaultedQueries.forEach((queryOptions) => {
		require_suspense.ensureSuspenseTimers(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		require_errorBoundaryUtils.ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
		});
		require_errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = react.useState(() => new _tanstack_query_core.QueriesObserver(client, defaultedQueries, options));
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
		const shouldSubscribe = !isRestoring && subscribed;
		react.useSyncExternalStore(react.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)) : _tanstack_query_core.noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		react.useEffect(() => {
		observer.setQueries(defaultedQueries, options);
		}, [
		defaultedQueries,
		options,
		observer
		]);
		const suspensePromises = optimisticResult.some((result, index) => require_suspense.shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && require_suspense.shouldSuspend(opts, result)) {
		const queryObserver = new _tanstack_query_core.QueryObserver(client, opts);
		return require_suspense.fetchOptimistic(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
		const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
		const query = defaultedQueries[index];
		return query && require_errorBoundaryUtils.getHasError({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		});
		if (firstSingleResultWhichShouldThrow === null \|\| firstSingleResultWhichShouldThrow === void 0 ? void 0 : firstSingleResultWhichShouldThrow.error) throw firstSingleResultWhichShouldThrow.error;
		return getCombinedResult(trackResult());
		}
		//#endregion
		exports.useQueries = useQueries;

		// src/useQueries.ts
		var useQueries_exports = {};
		__export(useQueries_exports, {
		useQueries: () => useQueries
		});
		module.exports = __toCommonJS(useQueries_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		var import_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		var import_suspense = require("./suspense.cjs");
		function useQueries({
		queries,
		...options
		}, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const isRestoring = (0, import_IsRestoringProvider.useIsRestoring)();
		const errorResetBoundary = (0, import_QueryErrorResetBoundary.useQueryErrorResetBoundary)();
		const defaultedQueries = React.useMemo(
		() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(
		opts
		);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
		return defaultedOptions;
		}),
		[queries, client, isRestoring]
		);
		defaultedQueries.forEach((queryOptions) => {
		(0, import_suspense.ensureSuspenseTimers)(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		(0, import_errorBoundaryUtils.ensurePreventErrorBoundaryRetry)(queryOptions, errorResetBoundary, query);
		});
		(0, import_errorBoundaryUtils.useClearResetErrorBoundary)(errorResetBoundary);
		const [observer] = React.useState(
		() => new import_query_core.QueriesObserver(
		client,
		defaultedQueries,
		options
		)
		);
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
		defaultedQueries,
		options.combine
		);
		const shouldSubscribe = !isRestoring && options.subscribed !== false;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => shouldSubscribe ? observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)) : import_query_core.noop,
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		React.useEffect(() => {
		observer.setQueries(
		defaultedQueries,
		options
		);
		}, [defaultedQueries, options, observer]);
		const shouldAtLeastOneSuspend = optimisticResult.some(
		(result, index) => (0, import_suspense.shouldSuspend)(defaultedQueries[index], result)
		);
		const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && (0, import_suspense.shouldSuspend)(opts, result)) {
		const queryObserver = new import_query_core.QueryObserver(client, opts);
		return (0, import_suspense.fetchOptimistic)(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) {
		throw Promise.all(suspensePromises);
		}
		const firstSingleResultWhichShouldThrow = optimisticResult.find(
		(result, index) => {
		const query = defaultedQueries[index];
		return query && (0, import_errorBoundaryUtils.getHasError)({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		}
		);
		if (firstSingleResultWhichShouldThrow == null ? void 0 : firstSingleResultWhichShouldThrow.error) {
		throw firstSingleResultWhichShouldThrow.error;
		}
		return getCombinedResult(trackResult());
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useQueries
		});
		//# sourceMappingURL=useQueries.cjs.map

+1

-1

build/legacy/useQueries.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n return defaultedOptions\n }),\n [queries, client, isRestoring],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAKO;AACP,iCAA+B;AAC/B,iCAA+B;AAC/B,qCAA2C;AAC3C,gCAIO;AACP,sBAIO;AAyLA,SAAS,WAId;AAAA,EACE;AAAA,EACA,GAAG;AACL,GAOA,aACiB;AACjB,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,kBAAc,2CAAe;AACnC,QAAM,yBAAqB,2DAA2B;AAEtD,QAAM,mBAAyB;AAAA,IAC7B,MACE,QAAQ,IAAI,CAAC,SAAS;AACpB,YAAM,mBAAmB,OAAO;AAAA,QAC9B;AAAA,MACF;AAGA,uBAAiB,qBAAqB,cAClC,gBACA;AAEJ,aAAO;AAAA,IACT,CAAC;AAAA,IACH,CAAC,SAAS,QAAQ,WAAW;AAAA,EAC/B;AAEA,mBAAiB,QAAQ,CAAC,iBAAiB;AACzC,8CAAqB,YAAY;AACjC,UAAM,QAAQ,OAAO,cAAc,EAAE,IAAI,aAAa,SAAS;AAC/D,mEAAgC,cAAc,oBAAoB,KAAK;AAAA,EACzE,CAAC;AAED,4DAA2B,kBAAkB;AAE7C,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,CAAC,kBAAkB,mBAAmB,WAAW,IACrD,SAAS;AAAA,IACP;AAAA,IACC,QAAoD;AAAA,EACvD;AAEF,QAAM,kBAAkB,CAAC,eAAe,QAAQ,eAAe;AAC/D,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBACC,kBACI,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC,IAC1D;AAAA,MACN,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS;AAAA,MACP;AAAA,MACA;AAAA,IACF;AAAA,EACF,GAAG,CAAC,kBAAkB,SAAS,QAAQ,CAAC;AAExC,QAAM,0BAA0B,iBAAiB;AAAA,IAAK,CAAC,QAAQ,cAC7D,+BAAc,iBAAiB,KAAK,GAAG,MAAM;AAAA,EAC/C;AAEA,QAAM,mBAAmB,0BACrB,iBAAiB,QAAQ,CAAC,QAAQ,UAAU;AAC1C,UAAM,OAAO,iBAAiB,KAAK;AAEnC,QAAI,YAAQ,+BAAc,MAAM,MAAM,GAAG;AACvC,YAAM,gBAAgB,IAAI,gCAAc,QAAQ,IAAI;AACpD,iBAAO,iCAAgB,MAAM,eAAe,kBAAkB;AAAA,IAChE;AACA,WAAO,CAAC;AAAA,EACV,CAAC,IACD,CAAC;AAEL,MAAI,iBAAiB,SAAS,GAAG;AAC/B,UAAM,QAAQ,IAAI,gBAAgB;AAAA,EACpC;AACA,QAAM,oCAAoC,iBAAiB;AAAA,IACzD,CAAC,QAAQ,UAAU;AACjB,YAAM,QAAQ,iBAAiB,KAAK;AACpC,aACE,aACA,uCAAY;AAAA,QACV;AAAA,QACA;AAAA,QACA,cAAc,MAAM;AAAA,QACpB,OAAO,OAAO,cAAc,EAAE,IAAI,MAAM,SAAS;AAAA,QACjD,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IAEL;AAAA,EACF;AAEA,MAAI,uFAAmC,OAAO;AAC5C,UAAM,kCAAkC;AAAA,EAC1C;AAEA,SAAO,kBAAkB,YAAY,CAAC;AACxC;","names":[]}
		{"version":3,"file":"useQueries.cjs","names":["useQueryClient","useIsRestoring","useQueryErrorResetBoundary","React","QueriesObserver","notifyManager","noop","shouldSuspend","QueryObserver","fetchOptimistic","getHasError"],"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const subscribed = options.subscribed !== false\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n return defaultedOptions\n }),\n [queries, client, isRestoring, subscribed],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;;;;AA8MA,SAAgB,WAId,EACE,SACA,GAAG,WAQL,aACiB;CACjB,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,MAAM,cAAcC,4BAAAA,eAAe;CACnC,MAAM,qBAAqBC,gCAAAA,2BAA2B;CACtD,MAAM,aAAa,QAAQ,eAAe;CAE1C,MAAM,mBAAmBC,MAAM,cAE3B,QAAQ,KAAK,SAAS;EACpB,MAAM,mBAAmB,OAAO,oBAC9B,IACF;EAGA,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;EAEN,OAAO;CACT,CAAC,GACH;EAAC;EAAS;EAAQ;EAAa;CAAU,CAC3C;CAEA,iBAAiB,SAAS,iBAAiB;EACzC,iBAAA,qBAAqB,YAAY;EACjC,MAAM,QAAQ,OAAO,cAAc,CAAC,CAAC,IAAI,aAAa,SAAS;EAC/D,2BAAA,gCAAgC,cAAc,oBAAoB,KAAK;CACzE,CAAC;CAED,2BAAA,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAYA,MAAM,eAErB,IAAIC,qBAAAA,gBACF,QACA,kBACA,OACF,CACJ;CAGA,MAAM,CAAC,kBAAkB,mBAAmB,eAC1C,SAAS,oBACP,kBACC,QAAoD,OACvD;CAEF,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJD,MAAM,aACH,kBACC,kBACI,SAAS,UAAUE,qBAAAA,cAAc,WAAW,aAAa,CAAC,IAC1DC,qBAAAA,MACN,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WACP,kBACA,OACF;CACF,GAAG;EAAC;EAAkB;EAAS;CAAQ,CAAC;CAMxC,MAAM,mBAJ0B,iBAAiB,MAAM,QAAQ,UAC7DC,iBAAAA,cAAc,iBAAiB,QAAQ,MAAM,CAGA,IAC3C,iBAAiB,SAAS,QAAQ,UAAU;EAC1C,MAAM,OAAO,iBAAiB;EAE9B,IAAI,QAAQA,iBAAAA,cAAc,MAAM,MAAM,GAAG;GACvC,MAAM,gBAAgB,IAAIC,qBAAAA,cAAc,QAAQ,IAAI;GACpD,OAAOC,iBAAAA,gBAAgB,MAAM,eAAe,kBAAkB;EAChE;EACA,OAAO,CAAC;CACV,CAAC,IACD,CAAC;CAEL,IAAI,iBAAiB,SAAS,GAC5B,MAAM,QAAQ,IAAI,gBAAgB;CAEpC,MAAM,oCAAoC,iBAAiB,MACxD,QAAQ,UAAU;EACjB,MAAM,QAAQ,iBAAiB;EAC/B,OACE,SACAC,2BAAAA,YAAY;GACV;GACA;GACA,cAAc,MAAM;GACpB,OAAO,OAAO,cAAc,CAAC,CAAC,IAAI,MAAM,SAAS;GACjD,UAAU,MAAM;EAClB,CAAC;CAEL,CACF;CAEA,IAAA,sCAAA,QAAA,sCAAA,KAAA,IAAA,KAAA,IAAI,kCAAmC,OACrC,MAAM,kCAAkC;CAG1C,OAAO,kBAAkB,YAAY,CAAC;AACxC"}

+57

-3

build/legacy/useQueries.d.cts

		@@ -1,3 +0,57 @@
		export { useQueries_alias_1 as useQueries } from './_tsup-dts-rollup.cjs';
		export { QueriesOptions_alias_1 as QueriesOptions } from './_tsup-dts-rollup.cjs';
		export { QueriesResults_alias_1 as QueriesResults } from './_tsup-dts-rollup.cjs';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.cjs";
		import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
		//#region src/useQueries.d.ts
		type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
		type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
		type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetUseQueryOptionsForUseQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetUseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseQueryResult<T[K]>; };
		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>; }];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { QueriesOptions, QueriesResults, useQueries };
		//# sourceMappingURL=useQueries.d.cts.map

+57

-3

build/legacy/useQueries.d.ts

		@@ -1,3 +0,57 @@
		export { useQueries_alias_1 as useQueries } from './_tsup-dts-rollup.js';
		export { QueriesOptions_alias_1 as QueriesOptions } from './_tsup-dts-rollup.js';
		export { QueriesResults_alias_1 as QueriesResults } from './_tsup-dts-rollup.js';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.js";
		import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
		//#region src/useQueries.d.ts
		type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
		type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
		type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetUseQueryOptionsForUseQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetUseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseQueryResult<T[K]>; };
		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>; }];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { QueriesOptions, QueriesResults, useQueries };
		//# sourceMappingURL=useQueries.d.ts.map

+61

-101

build/legacy/useQueries.js

		"use client";

		// src/useQueries.ts
		import * as React from "react";
		import {
		QueriesObserver,
		QueryObserver,
		noop,
		notifyManager
		} from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		import { useIsRestoring } from "./IsRestoringProvider.js";
		import { useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		} from "./errorBoundaryUtils.js";
		import {
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend
		} from "./suspense.js";
		function useQueries({
		queries,
		...options
		}, queryClient) {
		const client = useQueryClient(queryClient);
		const isRestoring = useIsRestoring();
		const errorResetBoundary = useQueryErrorResetBoundary();
		const defaultedQueries = React.useMemo(
		() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(
		opts
		);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
		return defaultedOptions;
		}),
		[queries, client, isRestoring]
		);
		defaultedQueries.forEach((queryOptions) => {
		ensureSuspenseTimers(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
		});
		useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = React.useState(
		() => new QueriesObserver(
		client,
		defaultedQueries,
		options
		)
		);
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
		defaultedQueries,
		options.combine
		);
		const shouldSubscribe = !isRestoring && options.subscribed !== false;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop,
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		React.useEffect(() => {
		observer.setQueries(
		defaultedQueries,
		options
		);
		}, [defaultedQueries, options, observer]);
		const shouldAtLeastOneSuspend = optimisticResult.some(
		(result, index) => shouldSuspend(defaultedQueries[index], result)
		);
		const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && shouldSuspend(opts, result)) {
		const queryObserver = new QueryObserver(client, opts);
		return fetchOptimistic(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) {
		throw Promise.all(suspensePromises);
		}
		const firstSingleResultWhichShouldThrow = optimisticResult.find(
		(result, index) => {
		const query = defaultedQueries[index];
		return query && getHasError({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		}
		);
		if (firstSingleResultWhichShouldThrow == null ? void 0 : firstSingleResultWhichShouldThrow.error) {
		throw firstSingleResultWhichShouldThrow.error;
		}
		return getCombinedResult(trackResult());
		import { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary } from "./errorBoundaryUtils.js";
		import { ensureSuspenseTimers, fetchOptimistic, shouldSuspend } from "./suspense.js";
		import * as React from "react";
		import { QueriesObserver, QueryObserver, noop, notifyManager } from "@tanstack/query-core";
		//#region src/useQueries.ts
		function useQueries({ queries, ...options }, queryClient) {
		const client = useQueryClient(queryClient);
		const isRestoring = useIsRestoring();
		const errorResetBoundary = useQueryErrorResetBoundary();
		const subscribed = options.subscribed !== false;
		const defaultedQueries = React.useMemo(() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(opts);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		return defaultedOptions;
		}), [
		queries,
		client,
		isRestoring,
		subscribed
		]);
		defaultedQueries.forEach((queryOptions) => {
		ensureSuspenseTimers(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
		});
		useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = React.useState(() => new QueriesObserver(client, defaultedQueries, options));
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(React.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		React.useEffect(() => {
		observer.setQueries(defaultedQueries, options);
		}, [
		defaultedQueries,
		options,
		observer
		]);
		const suspensePromises = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && shouldSuspend(opts, result)) {
		const queryObserver = new QueryObserver(client, opts);
		return fetchOptimistic(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
		const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
		const query = defaultedQueries[index];
		return query && getHasError({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		});
		if (firstSingleResultWhichShouldThrow === null \|\| firstSingleResultWhichShouldThrow === void 0 ? void 0 : firstSingleResultWhichShouldThrow.error) throw firstSingleResultWhichShouldThrow.error;
		return getCombinedResult(trackResult());
		}
		export {
		useQueries
		};
		//#endregion
		export { useQueries };

		//# sourceMappingURL=useQueries.js.map

+1

-1

build/legacy/useQueries.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n return defaultedOptions\n }),\n [queries, client, isRestoring],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAyLA,SAAS,WAId;AAAA,EACE;AAAA,EACA,GAAG;AACL,GAOA,aACiB;AACjB,QAAM,SAAS,eAAe,WAAW;AACzC,QAAM,cAAc,eAAe;AACnC,QAAM,qBAAqB,2BAA2B;AAEtD,QAAM,mBAAyB;AAAA,IAC7B,MACE,QAAQ,IAAI,CAAC,SAAS;AACpB,YAAM,mBAAmB,OAAO;AAAA,QAC9B;AAAA,MACF;AAGA,uBAAiB,qBAAqB,cAClC,gBACA;AAEJ,aAAO;AAAA,IACT,CAAC;AAAA,IACH,CAAC,SAAS,QAAQ,WAAW;AAAA,EAC/B;AAEA,mBAAiB,QAAQ,CAAC,iBAAiB;AACzC,yBAAqB,YAAY;AACjC,UAAM,QAAQ,OAAO,cAAc,EAAE,IAAI,aAAa,SAAS;AAC/D,oCAAgC,cAAc,oBAAoB,KAAK;AAAA,EACzE,CAAC;AAED,6BAA2B,kBAAkB;AAE7C,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,CAAC,kBAAkB,mBAAmB,WAAW,IACrD,SAAS;AAAA,IACP;AAAA,IACC,QAAoD;AAAA,EACvD;AAEF,QAAM,kBAAkB,CAAC,eAAe,QAAQ,eAAe;AAC/D,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBACC,kBACI,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D;AAAA,MACN,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS;AAAA,MACP;AAAA,MACA;AAAA,IACF;AAAA,EACF,GAAG,CAAC,kBAAkB,SAAS,QAAQ,CAAC;AAExC,QAAM,0BAA0B,iBAAiB;AAAA,IAAK,CAAC,QAAQ,UAC7D,cAAc,iBAAiB,KAAK,GAAG,MAAM;AAAA,EAC/C;AAEA,QAAM,mBAAmB,0BACrB,iBAAiB,QAAQ,CAAC,QAAQ,UAAU;AAC1C,UAAM,OAAO,iBAAiB,KAAK;AAEnC,QAAI,QAAQ,cAAc,MAAM,MAAM,GAAG;AACvC,YAAM,gBAAgB,IAAI,cAAc,QAAQ,IAAI;AACpD,aAAO,gBAAgB,MAAM,eAAe,kBAAkB;AAAA,IAChE;AACA,WAAO,CAAC;AAAA,EACV,CAAC,IACD,CAAC;AAEL,MAAI,iBAAiB,SAAS,GAAG;AAC/B,UAAM,QAAQ,IAAI,gBAAgB;AAAA,EACpC;AACA,QAAM,oCAAoC,iBAAiB;AAAA,IACzD,CAAC,QAAQ,UAAU;AACjB,YAAM,QAAQ,iBAAiB,KAAK;AACpC,aACE,SACA,YAAY;AAAA,QACV;AAAA,QACA;AAAA,QACA,cAAc,MAAM;AAAA,QACpB,OAAO,OAAO,cAAc,EAAE,IAAI,MAAM,SAAS;AAAA,QACjD,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IAEL;AAAA,EACF;AAEA,MAAI,uFAAmC,OAAO;AAC5C,UAAM,kCAAkC;AAAA,EAC1C;AAEA,SAAO,kBAAkB,YAAY,CAAC;AACxC;","names":[]}
		{"version":3,"file":"useQueries.js","names":[],"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const subscribed = options.subscribed !== false\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n return defaultedOptions\n }),\n [queries, client, isRestoring, subscribed],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;AA8MA,SAAgB,WAId,EACE,SACA,GAAG,WAQL,aACiB;CACjB,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,cAAc,eAAe;CACnC,MAAM,qBAAqB,2BAA2B;CACtD,MAAM,aAAa,QAAQ,eAAe;CAE1C,MAAM,mBAAmB,MAAM,cAE3B,QAAQ,KAAK,SAAS;EACpB,MAAM,mBAAmB,OAAO,oBAC9B,IACF;EAGA,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;EAEN,OAAO;CACT,CAAC,GACH;EAAC;EAAS;EAAQ;EAAa;CAAU,CAC3C;CAEA,iBAAiB,SAAS,iBAAiB;EACzC,qBAAqB,YAAY;EACjC,MAAM,QAAQ,OAAO,cAAc,CAAC,CAAC,IAAI,aAAa,SAAS;EAC/D,gCAAgC,cAAc,oBAAoB,KAAK;CACzE,CAAC;CAED,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAY,MAAM,eAErB,IAAI,gBACF,QACA,kBACA,OACF,CACJ;CAGA,MAAM,CAAC,kBAAkB,mBAAmB,eAC1C,SAAS,oBACP,kBACC,QAAoD,OACvD;CAEF,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJ,MAAM,aACH,kBACC,kBACI,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D,MACN,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WACP,kBACA,OACF;CACF,GAAG;EAAC;EAAkB;EAAS;CAAQ,CAAC;CAMxC,MAAM,mBAJ0B,iBAAiB,MAAM,QAAQ,UAC7D,cAAc,iBAAiB,QAAQ,MAAM,CAGA,IAC3C,iBAAiB,SAAS,QAAQ,UAAU;EAC1C,MAAM,OAAO,iBAAiB;EAE9B,IAAI,QAAQ,cAAc,MAAM,MAAM,GAAG;GACvC,MAAM,gBAAgB,IAAI,cAAc,QAAQ,IAAI;GACpD,OAAO,gBAAgB,MAAM,eAAe,kBAAkB;EAChE;EACA,OAAO,CAAC;CACV,CAAC,IACD,CAAC;CAEL,IAAI,iBAAiB,SAAS,GAC5B,MAAM,QAAQ,IAAI,gBAAgB;CAEpC,MAAM,oCAAoC,iBAAiB,MACxD,QAAQ,UAAU;EACjB,MAAM,QAAQ,iBAAiB;EAC/B,OACE,SACA,YAAY;GACV;GACA;GACA,cAAc,MAAM;GACpB,OAAO,OAAO,cAAc,CAAC,CAAC,IAAI,MAAM,SAAS;GACjD,UAAU,MAAM;EAClB,CAAC;CAEL,CACF;CAEA,IAAA,sCAAA,QAAA,sCAAA,KAAA,IAAA,KAAA,IAAI,kCAAmC,OACrC,MAAM,kCAAkC;CAG1C,OAAO,kBAAkB,YAAY,CAAC;AACxC"}

+8

-32

build/legacy/useQuery.cjs

		@@ -1,36 +0,12 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useQuery.ts
		var useQuery_exports = {};
		__export(useQuery_exports, {
		useQuery: () => useQuery
		});
		module.exports = __toCommonJS(useQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useQuery.ts
		function useQuery(options, queryClient) {
		return (0, import_useBaseQuery.useBaseQuery)(options, import_query_core.QueryObserver, queryClient);
		return require_useBaseQuery.useBaseQuery(options, _tanstack_query_core.QueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useQuery
		});
		//#endregion
		exports.useQuery = useQuery;

		//# sourceMappingURL=useQuery.cjs.map

+1

-1

build/legacy/useQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAA8B;AAC9B,0BAA6B;AA0CtB,SAAS,SAAS,SAA0B,aAA2B;AAC5E,aAAO,kCAAa,SAAS,iCAAe,WAAW;AACzD;","names":[]}
		{"version":3,"file":"useQuery.cjs","names":["useBaseQuery","QueryObserver"],"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;;;AA4CA,SAAgB,SAAS,SAA0B,aAA2B;CAC5E,OAAOA,qBAAAA,aAAa,SAASC,qBAAAA,eAAe,WAAW;AACzD"}

+10

-1

build/legacy/useQuery.d.cts

		@@ -1,1 +0,10 @@
		export { useQuery_alias_1 as useQuery } from './_tsup-dts-rollup.cjs';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.cjs";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from "./queryOptions.cjs";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useQuery.d.ts
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		//#endregion
		export { useQuery };
		//# sourceMappingURL=useQuery.d.cts.map

+10

-1

build/legacy/useQuery.d.ts

		@@ -1,1 +0,10 @@
		export { useQuery_alias_1 as useQuery } from './_tsup-dts-rollup.js';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.js";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from "./queryOptions.js";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useQuery.d.ts
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		//#endregion
		export { useQuery };
		//# sourceMappingURL=useQuery.d.ts.map

+6

-7

build/legacy/useQuery.js

		"use client";

		// src/useQuery.ts
		import { useBaseQuery } from "./useBaseQuery.js";
		import { QueryObserver } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		//#region src/useQuery.ts
		function useQuery(options, queryClient) {
		return useBaseQuery(options, QueryObserver, queryClient);
		return useBaseQuery(options, QueryObserver, queryClient);
		}
		export {
		useQuery
		};
		//#endregion
		export { useQuery };

		//# sourceMappingURL=useQuery.js.map

+1

-1

build/legacy/useQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;AACA,SAAS,qBAAqB;AAC9B,SAAS,oBAAoB;AA0CtB,SAAS,SAAS,SAA0B,aAA2B;AAC5E,SAAO,aAAa,SAAS,eAAe,WAAW;AACzD;","names":[]}
		{"version":3,"file":"useQuery.js","names":[],"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;;AA4CA,SAAgB,SAAS,SAA0B,aAA2B;CAC5E,OAAO,aAAa,SAAS,eAAe,WAAW;AACzD"}

+18

-47

build/legacy/useSuspenseInfiniteQuery.cjs

		@@ -1,51 +0,22 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useSuspenseInfiniteQuery.ts
		var useSuspenseInfiniteQuery_exports = {};
		__export(useSuspenseInfiniteQuery_exports, {
		useSuspenseInfiniteQuery: () => useSuspenseInfiniteQuery
		});
		module.exports = __toCommonJS(useSuspenseInfiniteQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_suspense = require("./suspense.cjs");
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useSuspenseInfiniteQuery.ts
		function useSuspenseInfiniteQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === import_query_core.skipToken) {
		console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		}
		return (0, import_useBaseQuery.useBaseQuery)(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: import_suspense.defaultThrowOnError
		},
		import_query_core.InfiniteQueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		return require_useBaseQuery.useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: require_suspense.defaultThrowOnError,
		placeholderData: void 0
		}, _tanstack_query_core.InfiniteQueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useSuspenseInfiniteQuery
		});
		//#endregion
		exports.useSuspenseInfiniteQuery = useSuspenseInfiniteQuery;

		//# sourceMappingURL=useSuspenseInfiniteQuery.cjs.map

+1

-1

build/legacy/useSuspenseInfiniteQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAAiD;AACjD,0BAA6B;AAC7B,sBAAoC;AAc7B,SAAS,yBAOd,SAOA,aAC+C;AAC/C,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,6BAAW;AAC1C,cAAQ,MAAM,uDAAuD;AAAA,IACvE;AAAA,EACF;AAEA,aAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseInfiniteQuery.cjs","names":["skipToken","useBaseQuery","defaultThrowOnError","InfiniteQueryObserver"],"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,yBAOd,SAOA,aAC+C;CAC/C,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoBA,qBAAAA,WAC/B,QAAQ,MAAM,uDAAuD;CAAA;CAIzE,OAAOC,qBAAAA,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAcC,iBAAAA;EACd,iBAAiB,KAAA;CACnB,GACAC,qBAAAA,uBACA,WACF;AACF"}

+7

-1

build/legacy/useSuspenseInfiniteQuery.d.cts

		@@ -1,1 +0,7 @@
		export { useSuspenseInfiniteQuery_alias_1 as useSuspenseInfiniteQuery } from './_tsup-dts-rollup.cjs';
		import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from "./types.cjs";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseInfiniteQuery.d.ts
		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseInfiniteQuery };
		//# sourceMappingURL=useSuspenseInfiniteQuery.d.cts.map

+7

-1

build/legacy/useSuspenseInfiniteQuery.d.ts

		@@ -1,1 +0,7 @@
		export { useSuspenseInfiniteQuery_alias_1 as useSuspenseInfiniteQuery } from './_tsup-dts-rollup.js';
		import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from "./types.js";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseInfiniteQuery.d.ts
		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseInfiniteQuery };
		//# sourceMappingURL=useSuspenseInfiniteQuery.d.ts.map

+16

-22

build/legacy/useSuspenseInfiniteQuery.js

		"use client";

		// src/useSuspenseInfiniteQuery.ts
		import { defaultThrowOnError } from "./suspense.js";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { InfiniteQueryObserver, skipToken } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { defaultThrowOnError } from "./suspense.js";
		//#region src/useSuspenseInfiniteQuery.ts
		function useSuspenseInfiniteQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) {
		console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		}
		return useBaseQuery(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError
		},
		InfiniteQueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		return useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError,
		placeholderData: void 0
		}, InfiniteQueryObserver, queryClient);
		}
		export {
		useSuspenseInfiniteQuery
		};
		//#endregion
		export { useSuspenseInfiniteQuery };

		//# sourceMappingURL=useSuspenseInfiniteQuery.js.map

+1

-1

build/legacy/useSuspenseInfiniteQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;AACA,SAAS,uBAAuB,iBAAiB;AACjD,SAAS,oBAAoB;AAC7B,SAAS,2BAA2B;AAc7B,SAAS,yBAOd,SAOA,aAC+C;AAC/C,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,WAAW;AAC1C,cAAQ,MAAM,uDAAuD;AAAA,IACvE;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseInfiniteQuery.js","names":[],"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;;;AAiBA,SAAgB,yBAOd,SAOA,aAC+C;CAC/C,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoB,WAC/B,QAAQ,MAAM,uDAAuD;CAAA;CAIzE,OAAO,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAc;EACd,iBAAiB,KAAA;CACnB,GACA,uBACA,WACF;AACF"}

+23

-52

build/legacy/useSuspenseQueries.cjs

		@@ -1,56 +0,27 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useSuspenseQueries.ts
		var useSuspenseQueries_exports = {};
		__export(useSuspenseQueries_exports, {
		useSuspenseQueries: () => useSuspenseQueries
		});
		module.exports = __toCommonJS(useSuspenseQueries_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useQueries = require("./useQueries.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_suspense = require("./suspense.cjs");
		const require_useQueries = require("./useQueries.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useSuspenseQueries.ts
		function useSuspenseQueries(options, queryClient) {
		return (0, import_useQueries.useQueries)(
		{
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === import_query_core.skipToken) {
		console.error("skipToken is not allowed for useSuspenseQueries");
		}
		}
		return {
		...query,
		suspense: true,
		throwOnError: import_suspense.defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		},
		queryClient
		);
		return require_useQueries.useQueries({
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseQueries");
		}
		return {
		...query,
		suspense: true,
		throwOnError: require_suspense.defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		}, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useSuspenseQueries
		});
		//#endregion
		exports.useSuspenseQueries = useSuspenseQueries;

		//# sourceMappingURL=useSuspenseQueries.cjs.map

+1

-1

build/legacy/useSuspenseQueries.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAA0B;AAC1B,wBAA2B;AAC3B,sBAAoC;AAyL7B,SAAS,mBAAmB,SAAc,aAA2B;AAC1E,aAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS,QAAQ,QAAQ,IAAI,CAAC,UAAe;AAC3C,YAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,cAAI,MAAM,YAAY,6BAAW;AAC/B,oBAAQ,MAAM,iDAAiD;AAAA,UACjE;AAAA,QACF;AAEA,eAAO;AAAA,UACL,GAAG;AAAA,UACH,UAAU;AAAA,UACV,cAAc;AAAA,UACd,SAAS;AAAA,UACT,iBAAiB;AAAA,QACnB;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQueries.cjs","names":["useQueries","skipToken","defaultThrowOnError"],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;;;;AA4LA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAOA,mBAAAA,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAYC,qBAAAA,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAcC,iBAAAA;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}

+60

-3

build/legacy/useSuspenseQueries.d.cts

		@@ -1,3 +0,60 @@
		export { useSuspenseQueries_alias_1 as useSuspenseQueries } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesOptions_alias_1 as SuspenseQueriesOptions } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesResults_alias_1 as SuspenseQueriesResults } from './_tsup-dts-rollup.cjs';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
		import { DefaultError, QueryClient, QueryFunction, ThrowOnError } from "@tanstack/query-core";
		//#region src/useSuspenseQueries.d.ts
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
		type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[...Tails], [...TResults, GetUseSuspenseQueryOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[...Tails], [...TResults, GetUseSuspenseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]>; };
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]>; }];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };
		//# sourceMappingURL=useSuspenseQueries.d.cts.map

+60

-3

build/legacy/useSuspenseQueries.d.ts

		@@ -1,3 +0,60 @@
		export { useSuspenseQueries_alias_1 as useSuspenseQueries } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesOptions_alias_1 as SuspenseQueriesOptions } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesResults_alias_1 as SuspenseQueriesResults } from './_tsup-dts-rollup.js';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
		import { DefaultError, QueryClient, QueryFunction, ThrowOnError } from "@tanstack/query-core";
		//#region src/useSuspenseQueries.d.ts
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
		type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[...Tails], [...TResults, GetUseSuspenseQueryOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[...Tails], [...TResults, GetUseSuspenseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]>; };
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]>; }];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };
		//# sourceMappingURL=useSuspenseQueries.d.ts.map

+21

-27

build/legacy/useSuspenseQueries.js

		"use client";

		// src/useSuspenseQueries.ts
		import { defaultThrowOnError } from "./suspense.js";
		import { useQueries } from "./useQueries.js";
		import { skipToken } from "@tanstack/query-core";
		import { useQueries } from "./useQueries.js";
		import { defaultThrowOnError } from "./suspense.js";
		//#region src/useSuspenseQueries.ts
		function useSuspenseQueries(options, queryClient) {
		return useQueries(
		{
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === skipToken) {
		console.error("skipToken is not allowed for useSuspenseQueries");
		}
		}
		return {
		...query,
		suspense: true,
		throwOnError: defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		},
		queryClient
		);
		return useQueries({
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQueries");
		}
		return {
		...query,
		suspense: true,
		throwOnError: defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		}, queryClient);
		}
		export {
		useSuspenseQueries
		};
		//#endregion
		export { useSuspenseQueries };

		//# sourceMappingURL=useSuspenseQueries.js.map

+1

-1

build/legacy/useSuspenseQueries.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;AACA,SAAS,iBAAiB;AAC1B,SAAS,kBAAkB;AAC3B,SAAS,2BAA2B;AAyL7B,SAAS,mBAAmB,SAAc,aAA2B;AAC1E,SAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS,QAAQ,QAAQ,IAAI,CAAC,UAAe;AAC3C,YAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,cAAI,MAAM,YAAY,WAAW;AAC/B,oBAAQ,MAAM,iDAAiD;AAAA,UACjE;AAAA,QACF;AAEA,eAAO;AAAA,UACL,GAAG;AAAA,UACH,UAAU;AAAA,UACV,cAAc;AAAA,UACd,SAAS;AAAA,UACT,iBAAiB;AAAA,QACnB;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQueries.js","names":[],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;;;AA4LA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAO,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAY,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAc;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}

+18

-48

build/legacy/useSuspenseQuery.cjs

		@@ -1,52 +0,22 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useSuspenseQuery.ts
		var useSuspenseQuery_exports = {};
		__export(useSuspenseQuery_exports, {
		useSuspenseQuery: () => useSuspenseQuery
		});
		module.exports = __toCommonJS(useSuspenseQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_suspense = require("./suspense.cjs");
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useSuspenseQuery.ts
		function useSuspenseQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === import_query_core.skipToken) {
		console.error("skipToken is not allowed for useSuspenseQuery");
		}
		}
		return (0, import_useBaseQuery.useBaseQuery)(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: import_suspense.defaultThrowOnError,
		placeholderData: void 0
		},
		import_query_core.QueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseQuery");
		}
		return require_useBaseQuery.useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: require_suspense.defaultThrowOnError,
		placeholderData: void 0
		}, _tanstack_query_core.QueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useSuspenseQuery
		});
		//#endregion
		exports.useSuspenseQuery = useSuspenseQuery;

		//# sourceMappingURL=useSuspenseQuery.cjs.map

+1

-1

build/legacy/useSuspenseQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAAyC;AACzC,0BAA6B;AAC7B,sBAAoC;AAI7B,SAAS,iBAMd,SACA,aACuC;AACvC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,6BAAW;AAC1C,cAAQ,MAAM,+CAA+C;AAAA,IAC/D;AAAA,EACF;AAEA,aAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,MACd,iBAAiB;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQuery.cjs","names":["skipToken","useBaseQuery","defaultThrowOnError","QueryObserver"],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;AAOA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoBA,qBAAAA,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAOC,qBAAAA,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAcC,iBAAAA;EACd,iBAAiB,KAAA;CACnB,GACAC,qBAAAA,eACA,WACF;AACF"}

+7

-1

build/legacy/useSuspenseQuery.d.cts

		@@ -1,1 +0,7 @@
		export { useSuspenseQuery_alias_1 as useSuspenseQuery } from './_tsup-dts-rollup.cjs';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseQuery.d.ts
		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseQuery };
		//# sourceMappingURL=useSuspenseQuery.d.cts.map

+7

-1

build/legacy/useSuspenseQuery.d.ts

		@@ -1,1 +0,7 @@
		export { useSuspenseQuery_alias_1 as useSuspenseQuery } from './_tsup-dts-rollup.js';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseQuery.d.ts
		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseQuery };
		//# sourceMappingURL=useSuspenseQuery.d.ts.map

+16

-23

build/legacy/useSuspenseQuery.js

		"use client";

		// src/useSuspenseQuery.ts
		import { defaultThrowOnError } from "./suspense.js";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { QueryObserver, skipToken } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { defaultThrowOnError } from "./suspense.js";
		//#region src/useSuspenseQuery.ts
		function useSuspenseQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) {
		console.error("skipToken is not allowed for useSuspenseQuery");
		}
		}
		return useBaseQuery(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError,
		placeholderData: void 0
		},
		QueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQuery");
		}
		return useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError,
		placeholderData: void 0
		}, QueryObserver, queryClient);
		}
		export {
		useSuspenseQuery
		};
		//#endregion
		export { useSuspenseQuery };

		//# sourceMappingURL=useSuspenseQuery.js.map

+1

-1

build/legacy/useSuspenseQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;AACA,SAAS,eAAe,iBAAiB;AACzC,SAAS,oBAAoB;AAC7B,SAAS,2BAA2B;AAI7B,SAAS,iBAMd,SACA,aACuC;AACvC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,WAAW;AAC1C,cAAQ,MAAM,+CAA+C;AAAA,IAC/D;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,MACd,iBAAiB;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQuery.js","names":[],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;AAOA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoB,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAO,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAc;EACd,iBAAiB,KAAA;CACnB,GACA,eACA,WACF;AACF"}

+22

-64

build/modern/errorBoundaryUtils.cjs

		@@ -1,69 +0,27 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/errorBoundaryUtils.ts
		const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
		const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? (0, _tanstack_query_core.shouldThrowError)(options.throwOnError, [query.state.error, query]) : options.throwOnError;
		if (options.suspense \|\| throwOnError) {
		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
		}
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		const useClearResetErrorBoundary = (errorResetBoundary) => {
		react.useEffect(() => {
		errorResetBoundary.clearReset();
		}, [errorResetBoundary]);
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		const getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
		return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 \|\| (0, _tanstack_query_core.shouldThrowError)(throwOnError, [result.error, query]));
		};
		//#endregion
		exports.ensurePreventErrorBoundaryRetry = ensurePreventErrorBoundaryRetry;
		exports.getHasError = getHasError;
		exports.useClearResetErrorBoundary = useClearResetErrorBoundary;

		// src/errorBoundaryUtils.ts
		var errorBoundaryUtils_exports = {};
		__export(errorBoundaryUtils_exports, {
		ensurePreventErrorBoundaryRetry: () => ensurePreventErrorBoundaryRetry,
		getHasError: () => getHasError,
		useClearResetErrorBoundary: () => useClearResetErrorBoundary
		});
		module.exports = __toCommonJS(errorBoundaryUtils_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
		const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? (0, import_query_core.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) => {
		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 \|\| (0, import_query_core.shouldThrowError)(throwOnError, [result.error, query]));
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		});
		//# sourceMappingURL=errorBoundaryUtils.cjs.map

+1

-1

build/modern/errorBoundaryUtils.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (\n options.suspense \|\|\n options.experimental_prefetchInRender \|\|\n throwOnError\n ) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AACvB,wBAAiC;AAU1B,IAAM,kCAAkC,CAO7C,SAOA,oBACA,UACG;AACH,QAAM,eACJ,OAAO,MAAM,SAAS,OAAO,QAAQ,iBAAiB,iBAClD,oCAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;AAEd,MACE,QAAQ,YACR,QAAQ,iCACR,cACA;AAEA,QAAI,CAAC,mBAAmB,QAAQ,GAAG;AACjC,cAAQ,eAAe;AAAA,IACzB;AAAA,EACF;AACF;AAEO,IAAM,6BAA6B,CACxC,uBACG;AACH,EAAM,gBAAU,MAAM;AACpB,uBAAmB,WAAW;AAAA,EAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEO,IAAM,cAAc,CAMzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAMM;AACJ,SACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,cAC5B,oCAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D;","names":[]}
		{"version":3,"file":"errorBoundaryUtils.cjs","names":["shouldThrowError"],"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (options.suspense \|\| throwOnError) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;;;;;AAYA,MAAa,mCAOX,SAOA,oBACA,UACG;CACH,MAAM,eACJ,OAAO,MAAM,SAAS,OAAO,QAAQ,iBAAiB,cAAA,GAClDA,qBAAAA,iBAAAA,CAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;CAEd,IAAI,QAAQ,YAAY,cAElB;MAAA,CAAC,mBAAmB,QAAQ,GAC9B,QAAQ,eAAe;CAAA;AAG7B;AAEA,MAAa,8BACX,uBACG;CACH,MAAM,gBAAgB;EACpB,mBAAmB,WAAW;CAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEA,MAAa,eAMX,EACA,QACA,oBACA,cACA,OACA,eAOI;CACJ,OACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,KAAA,MAAA,GAC5BA,qBAAAA,iBAAAA,CAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D"}

+15

-3

build/modern/errorBoundaryUtils.d.cts

		@@ -1,3 +0,15 @@
		export { ensurePreventErrorBoundaryRetry } from './_tsup-dts-rollup.cjs';
		export { useClearResetErrorBoundary } from './_tsup-dts-rollup.cjs';
		export { getHasError } from './_tsup-dts-rollup.cjs';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.cjs";
		import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
		//#region src/errorBoundaryUtils.d.ts
		declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;
		declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
		declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;
		//#endregion
		export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
		//# sourceMappingURL=errorBoundaryUtils.d.cts.map

+15

-3

build/modern/errorBoundaryUtils.d.ts

		@@ -1,3 +0,15 @@
		export { ensurePreventErrorBoundaryRetry } from './_tsup-dts-rollup.js';
		export { useClearResetErrorBoundary } from './_tsup-dts-rollup.js';
		export { getHasError } from './_tsup-dts-rollup.js';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.js";
		import { DefaultedQueryObserverOptions, Query, QueryKey, QueryObserverResult, ThrowOnError } from "@tanstack/query-core";
		//#region src/errorBoundaryUtils.d.ts
		declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;
		declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;
		declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;
		//#endregion
		export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };
		//# sourceMappingURL=errorBoundaryUtils.d.ts.map

+15

-26

build/modern/errorBoundaryUtils.js

		"use client";

		// src/errorBoundaryUtils.ts
		import * as React from "react";
		import { shouldThrowError } from "@tanstack/query-core";
		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;
		}
		}
		//#region src/errorBoundaryUtils.ts
		const 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 \|\| throwOnError) {
		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
		}
		};
		var useClearResetErrorBoundary = (errorResetBoundary) => {
		React.useEffect(() => {
		errorResetBoundary.clearReset();
		}, [errorResetBoundary]);
		const useClearResetErrorBoundary = (errorResetBoundary) => {
		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]));
		const getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
		return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 \|\| shouldThrowError(throwOnError, [result.error, query]));
		};
		export {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		};
		//#endregion
		export { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };

		//# sourceMappingURL=errorBoundaryUtils.js.map

+1

-1

build/modern/errorBoundaryUtils.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (\n options.suspense \|\|\n options.experimental_prefetchInRender \|\|\n throwOnError\n ) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AACvB,SAAS,wBAAwB;AAU1B,IAAM,kCAAkC,CAO7C,SAOA,oBACA,UACG;AACH,QAAM,eACJ,OAAO,MAAM,SAAS,OAAO,QAAQ,iBAAiB,aAClD,iBAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;AAEd,MACE,QAAQ,YACR,QAAQ,iCACR,cACA;AAEA,QAAI,CAAC,mBAAmB,QAAQ,GAAG;AACjC,cAAQ,eAAe;AAAA,IACzB;AAAA,EACF;AACF;AAEO,IAAM,6BAA6B,CACxC,uBACG;AACH,EAAM,gBAAU,MAAM;AACpB,uBAAmB,WAAW;AAAA,EAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEO,IAAM,cAAc,CAMzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAMM;AACJ,SACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,UAC5B,iBAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D;","names":[]}
		{"version":3,"file":"errorBoundaryUtils.js","names":[],"sources":["../../src/errorBoundaryUtils.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (options.suspense \|\| throwOnError) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult<TData, TError>\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined\n suspense: boolean \| undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) \|\|\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n"],"mappings":";;;;AAYA,MAAa,mCAOX,SAOA,oBACA,UACG;CACH,MAAM,eACJ,OAAO,MAAM,SAAS,OAAO,QAAQ,iBAAiB,aAClD,iBAAiB,QAAQ,cAAc,CAAC,MAAM,MAAM,OAAO,KAAK,CAAC,IACjE,QAAQ;CAEd,IAAI,QAAQ,YAAY,cAElB;MAAA,CAAC,mBAAmB,QAAQ,GAC9B,QAAQ,eAAe;CAAA;AAG7B;AAEA,MAAa,8BACX,uBACG;CACH,MAAM,gBAAgB;EACpB,mBAAmB,WAAW;CAChC,GAAG,CAAC,kBAAkB,CAAC;AACzB;AAEA,MAAa,eAMX,EACA,QACA,oBACA,cACA,OACA,eAOI;CACJ,OACE,OAAO,WACP,CAAC,mBAAmB,QAAQ,KAC5B,CAAC,OAAO,cACR,UACE,YAAY,OAAO,SAAS,KAAA,KAC5B,iBAAiB,cAAc,CAAC,OAAO,OAAO,KAAK,CAAC;AAE1D"}

+35

-87

build/modern/HydrationBoundary.cjs

		@@ -1,91 +0,39 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/HydrationBoundary.tsx
		const HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const optionsRef = react.useRef(options);
		react.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = react.useMemo(() => {
		if (state) {
		if (typeof state !== "object") return;
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) newQueries.push(dehydratedQuery);
		else if (dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt) existingQueries.push(dehydratedQuery);
		}
		if (newQueries.length > 0) (0, _tanstack_query_core.hydrate)(client, { queries: newQueries }, optionsRef.current);
		if (existingQueries.length > 0) return existingQueries;
		}
		}, [client, state]);
		react.useEffect(() => {
		if (hydrationQueue) (0, _tanstack_query_core.hydrate)(client, { queries: hydrationQueue }, optionsRef.current);
		}, [client, hydrationQueue]);
		return children;
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		//#endregion
		exports.HydrationBoundary = HydrationBoundary;

		// src/HydrationBoundary.tsx
		var HydrationBoundary_exports = {};
		__export(HydrationBoundary_exports, {
		HydrationBoundary: () => HydrationBoundary
		});
		module.exports = __toCommonJS(HydrationBoundary_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var HydrationBoundary = ({
		children,
		options = {},
		state,
		queryClient
		}) => {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const optionsRef = React.useRef(options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = React.useMemo(() => {
		if (state) {
		if (typeof state !== "object") {
		return;
		}
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) {
		newQueries.push(dehydratedQuery);
		} else {
		const hydrationIsNewer = dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt;
		if (hydrationIsNewer) {
		existingQueries.push(dehydratedQuery);
		}
		}
		}
		if (newQueries.length > 0) {
		(0, import_query_core.hydrate)(client, { queries: newQueries }, optionsRef.current);
		}
		if (existingQueries.length > 0) {
		return existingQueries;
		}
		}
		return void 0;
		}, [client, state]);
		React.useEffect(() => {
		if (hydrationQueue) {
		(0, import_query_core.hydrate)(client, { queries: hydrationQueue }, optionsRef.current);
		}
		}, [client, hydrationQueue]);
		return children;
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		HydrationBoundary
		});
		//# sourceMappingURL=HydrationBoundary.cjs.map

+1

-1

build/modern/HydrationBoundary.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAAwB;AACxB,iCAA+B;AAoBxB,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA,UAAU,CAAC;AAAA,EACX;AAAA,EACA;AACF,MAA8B;AAC5B,QAAM,aAAS,2CAAe,WAAW;AAEzC,QAAM,aAAmB,aAAO,OAAO;AACvC,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAiBD,QAAM,iBACE,cAAQ,MAAM;AAClB,QAAI,OAAO;AACT,UAAI,OAAO,UAAU,UAAU;AAC7B;AAAA,MACF;AAEA,YAAM,aAAa,OAAO,cAAc;AAKxC,YAAM,UAAU,MAAM,WAAW,CAAC;AAElC,YAAM,aAAyC,CAAC;AAChD,YAAM,kBAA8C,CAAC;AACrD,iBAAW,mBAAmB,SAAS;AACrC,cAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;AAE9D,YAAI,CAAC,eAAe;AAClB,qBAAW,KAAK,eAAe;AAAA,QACjC,OAAO;AACL,gBAAM,mBACJ,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,UACjC,gBAAgB,eACd,cAAc,MAAM;AAE1B,cAAI,kBAAkB;AACpB,4BAAgB,KAAK,eAAe;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,UAAI,WAAW,SAAS,GAAG;AAIzB,uCAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;AAAA,MAC7D;AACA,UAAI,gBAAgB,SAAS,GAAG;AAC9B,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,CAAC,QAAQ,KAAK,CAAC;AAEpB,EAAM,gBAAU,MAAM;AACpB,QAAI,gBAAgB;AAClB,qCAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;AAAA,IACjE;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,CAAC;AAE3B,SAAO;AACT;","names":[]}
		{"version":3,"file":"HydrationBoundary.cjs","names":["useQueryClient","React"],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;;;;;;AAwBA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,MAAM,aAAaC,MAAM,OAAO,OAAO;CACvC,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,iBACJA,MAAM,cAAc;EAClB,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAKxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAY/B,IATE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eACd,cAAc,MAAM,eAGxB,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAItB,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAEpB,MAAM,gBAAgB;EACpB,IAAI,gBACF,CAAA,GAAA,qBAAA,QAAA,CAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO;AACT"}

+15

-2

build/modern/HydrationBoundary.d.cts

		@@ -1,2 +0,15 @@
		export { HydrationBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { HydrationBoundary } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		import { DehydratedState, HydrateOptions, OmitKeyof, QueryClient } from "@tanstack/query-core";
		//#region src/HydrationBoundary.d.ts
		interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React.ReactNode;
		queryClient?: QueryClient;
		}
		declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => React.ReactElement;
		//#endregion
		export { HydrationBoundary, HydrationBoundaryProps };
		//# sourceMappingURL=HydrationBoundary.d.cts.map

+15

-2

build/modern/HydrationBoundary.d.ts

		@@ -1,2 +0,15 @@
		export { HydrationBoundaryProps } from './_tsup-dts-rollup.js';
		export { HydrationBoundary } from './_tsup-dts-rollup.js';
		import * as React from "react";
		import { DehydratedState, HydrateOptions, OmitKeyof, QueryClient } from "@tanstack/query-core";
		//#region src/HydrationBoundary.d.ts
		interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React.ReactNode;
		queryClient?: QueryClient;
		}
		declare const HydrationBoundary: ({ children, options, state, queryClient }: HydrationBoundaryProps) => React.ReactElement;
		//#endregion
		export { HydrationBoundary, HydrationBoundaryProps };
		//# sourceMappingURL=HydrationBoundary.d.ts.map

+31

-52

build/modern/HydrationBoundary.js

		"use client";

		// src/HydrationBoundary.tsx
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import { hydrate } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		var HydrationBoundary = ({
		children,
		options = {},
		state,
		queryClient
		}) => {
		const client = useQueryClient(queryClient);
		const optionsRef = React.useRef(options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = React.useMemo(() => {
		if (state) {
		if (typeof state !== "object") {
		return;
		}
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) {
		newQueries.push(dehydratedQuery);
		} else {
		const hydrationIsNewer = dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt;
		if (hydrationIsNewer) {
		existingQueries.push(dehydratedQuery);
		}
		}
		}
		if (newQueries.length > 0) {
		hydrate(client, { queries: newQueries }, optionsRef.current);
		}
		if (existingQueries.length > 0) {
		return existingQueries;
		}
		}
		return void 0;
		}, [client, state]);
		React.useEffect(() => {
		if (hydrationQueue) {
		hydrate(client, { queries: hydrationQueue }, optionsRef.current);
		}
		}, [client, hydrationQueue]);
		return children;
		//#region src/HydrationBoundary.tsx
		const HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
		const client = useQueryClient(queryClient);
		const optionsRef = React.useRef(options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		const hydrationQueue = React.useMemo(() => {
		if (state) {
		if (typeof state !== "object") return;
		const queryCache = client.getQueryCache();
		const queries = state.queries \|\| [];
		const newQueries = [];
		const existingQueries = [];
		for (const dehydratedQuery of queries) {
		const existingQuery = queryCache.get(dehydratedQuery.queryHash);
		if (!existingQuery) newQueries.push(dehydratedQuery);
		else if (dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt \|\| dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt) existingQueries.push(dehydratedQuery);
		}
		if (newQueries.length > 0) hydrate(client, { queries: newQueries }, optionsRef.current);
		if (existingQueries.length > 0) return existingQueries;
		}
		}, [client, state]);
		React.useEffect(() => {
		if (hydrationQueue) hydrate(client, { queries: hydrationQueue }, optionsRef.current);
		}, [client, hydrationQueue]);
		return children;
		};
		export {
		HydrationBoundary
		};
		//#endregion
		export { HydrationBoundary };

		//# sourceMappingURL=HydrationBoundary.js.map

+1

-1

build/modern/HydrationBoundary.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAoBxB,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA,UAAU,CAAC;AAAA,EACX;AAAA,EACA;AACF,MAA8B;AAC5B,QAAM,SAAS,eAAe,WAAW;AAEzC,QAAM,aAAmB,aAAO,OAAO;AACvC,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAiBD,QAAM,iBACE,cAAQ,MAAM;AAClB,QAAI,OAAO;AACT,UAAI,OAAO,UAAU,UAAU;AAC7B;AAAA,MACF;AAEA,YAAM,aAAa,OAAO,cAAc;AAKxC,YAAM,UAAU,MAAM,WAAW,CAAC;AAElC,YAAM,aAAyC,CAAC;AAChD,YAAM,kBAA8C,CAAC;AACrD,iBAAW,mBAAmB,SAAS;AACrC,cAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;AAE9D,YAAI,CAAC,eAAe;AAClB,qBAAW,KAAK,eAAe;AAAA,QACjC,OAAO;AACL,gBAAM,mBACJ,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,UACjC,gBAAgB,eACd,cAAc,MAAM;AAE1B,cAAI,kBAAkB;AACpB,4BAAgB,KAAK,eAAe;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,UAAI,WAAW,SAAS,GAAG;AAIzB,gBAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;AAAA,MAC7D;AACA,UAAI,gBAAgB,SAAS,GAAG;AAC9B,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,CAAC,QAAQ,KAAK,CAAC;AAEpB,EAAM,gBAAU,MAAM;AACpB,QAAI,gBAAgB;AAClB,cAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;AAAA,IACjE;AAAA,EACF,GAAG,CAAC,QAAQ,cAAc,CAAC;AAE3B,SAAO;AACT;","names":[]}
		{"version":3,"file":"HydrationBoundary.js","names":[],"sources":["../../src/HydrationBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState \| null \| undefined\n options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {\n defaultOptions?: OmitKeyof<\n Exclude<HydrateOptions['defaultOptions'], undefined>,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] \| undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries \|\| []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt \|\|\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n"],"mappings":";;;;;AAwBA,MAAa,qBAAqB,EAChC,UACA,UAAU,CAAC,GACX,OACA,kBAC4B;CAC5B,MAAM,SAAS,eAAe,WAAW;CAEzC,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAiBD,MAAM,iBACJ,MAAM,cAAc;EAClB,IAAI,OAAO;GACT,IAAI,OAAO,UAAU,UACnB;GAGF,MAAM,aAAa,OAAO,cAAc;GAKxC,MAAM,UAAU,MAAM,WAAW,CAAC;GAElC,MAAM,aAAyC,CAAC;GAChD,MAAM,kBAA8C,CAAC;GACrD,KAAK,MAAM,mBAAmB,SAAS;IACrC,MAAM,gBAAgB,WAAW,IAAI,gBAAgB,SAAS;IAE9D,IAAI,CAAC,eACH,WAAW,KAAK,eAAe;SAY/B,IATE,gBAAgB,MAAM,gBACpB,cAAc,MAAM,iBACrB,gBAAgB,WACf,cAAc,MAAM,WAAW,aAC/B,cAAc,MAAM,gBAAgB,cACpC,gBAAgB,iBAAiB,KAAA,KACjC,gBAAgB,eACd,cAAc,MAAM,eAGxB,gBAAgB,KAAK,eAAe;GAG1C;GAEA,IAAI,WAAW,SAAS,GAItB,QAAQ,QAAQ,EAAE,SAAS,WAAW,GAAG,WAAW,OAAO;GAE7D,IAAI,gBAAgB,SAAS,GAC3B,OAAO;EAEX;CAEF,GAAG,CAAC,QAAQ,KAAK,CAAC;CAEpB,MAAM,gBAAgB;EACpB,IAAI,gBACF,QAAQ,QAAQ,EAAE,SAAS,eAAe,GAAG,WAAW,OAAO;CAEnE,GAAG,CAAC,QAAQ,cAAc,CAAC;CAE3B,OAAO;AACT"}

+54

-95

build/modern/index.cjs

		@@ -1,97 +0,56 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		const require_HydrationBoundary = require("./HydrationBoundary.cjs");
		const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		const require_useQueries = require("./useQueries.cjs");
		const require_useQuery = require("./useQuery.cjs");
		const require_useSuspenseQuery = require("./useSuspenseQuery.cjs");
		const require_useSuspenseInfiniteQuery = require("./useSuspenseInfiniteQuery.cjs");
		const require_useSuspenseQueries = require("./useSuspenseQueries.cjs");
		const require_usePrefetchQuery = require("./usePrefetchQuery.cjs");
		const require_usePrefetchInfiniteQuery = require("./usePrefetchInfiniteQuery.cjs");
		const require_queryOptions = require("./queryOptions.cjs");
		const require_infiniteQueryOptions = require("./infiniteQueryOptions.cjs");
		const require_useIsFetching = require("./useIsFetching.cjs");
		const require_useMutationState = require("./useMutationState.cjs");
		const require_useMutation = require("./useMutation.cjs");
		const require_mutationOptions = require("./mutationOptions.cjs");
		const require_useInfiniteQuery = require("./useInfiniteQuery.cjs");
		//#region src/index.ts
		/* istanbul ignore file */
		//#endregion
		exports.HydrationBoundary = require_HydrationBoundary.HydrationBoundary;
		exports.IsRestoringProvider = require_IsRestoringProvider.IsRestoringProvider;
		exports.QueryClientContext = require_QueryClientProvider.QueryClientContext;
		exports.QueryClientProvider = require_QueryClientProvider.QueryClientProvider;
		exports.QueryErrorResetBoundary = require_QueryErrorResetBoundary.QueryErrorResetBoundary;
		exports.infiniteQueryOptions = require_infiniteQueryOptions.infiniteQueryOptions;
		exports.mutationOptions = require_mutationOptions.mutationOptions;
		exports.queryOptions = require_queryOptions.queryOptions;
		exports.useInfiniteQuery = require_useInfiniteQuery.useInfiniteQuery;
		exports.useIsFetching = require_useIsFetching.useIsFetching;
		exports.useIsMutating = require_useMutationState.useIsMutating;
		exports.useIsRestoring = require_IsRestoringProvider.useIsRestoring;
		exports.useMutation = require_useMutation.useMutation;
		exports.useMutationState = require_useMutationState.useMutationState;
		exports.usePrefetchInfiniteQuery = require_usePrefetchInfiniteQuery.usePrefetchInfiniteQuery;
		exports.usePrefetchQuery = require_usePrefetchQuery.usePrefetchQuery;
		exports.useQueries = require_useQueries.useQueries;
		exports.useQuery = require_useQuery.useQuery;
		exports.useQueryClient = require_QueryClientProvider.useQueryClient;
		exports.useQueryErrorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary;
		exports.useSuspenseInfiniteQuery = require_useSuspenseInfiniteQuery.useSuspenseInfiniteQuery;
		exports.useSuspenseQueries = require_useSuspenseQueries.useSuspenseQueries;
		exports.useSuspenseQuery = require_useSuspenseQuery.useSuspenseQuery;
		var _tanstack_query_core = require("@tanstack/query-core");
		Object.keys(_tanstack_query_core).forEach(function(k) {
		if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
		enumerable: true,
		get: function() {
		return _tanstack_query_core[k];
		}
		});
		});

		// src/index.ts
		var index_exports = {};
		__export(index_exports, {
		HydrationBoundary: () => import_HydrationBoundary.HydrationBoundary,
		IsRestoringProvider: () => import_IsRestoringProvider.IsRestoringProvider,
		QueryClientContext: () => import_QueryClientProvider.QueryClientContext,
		QueryClientProvider: () => import_QueryClientProvider.QueryClientProvider,
		QueryErrorResetBoundary: () => import_QueryErrorResetBoundary.QueryErrorResetBoundary,
		infiniteQueryOptions: () => import_infiniteQueryOptions.infiniteQueryOptions,
		mutationOptions: () => import_mutationOptions.mutationOptions,
		queryOptions: () => import_queryOptions.queryOptions,
		useInfiniteQuery: () => import_useInfiniteQuery.useInfiniteQuery,
		useIsFetching: () => import_useIsFetching.useIsFetching,
		useIsMutating: () => import_useMutationState.useIsMutating,
		useIsRestoring: () => import_IsRestoringProvider.useIsRestoring,
		useMutation: () => import_useMutation.useMutation,
		useMutationState: () => import_useMutationState.useMutationState,
		usePrefetchInfiniteQuery: () => import_usePrefetchInfiniteQuery.usePrefetchInfiniteQuery,
		usePrefetchQuery: () => import_usePrefetchQuery.usePrefetchQuery,
		useQueries: () => import_useQueries.useQueries,
		useQuery: () => import_useQuery.useQuery,
		useQueryClient: () => import_QueryClientProvider.useQueryClient,
		useQueryErrorResetBoundary: () => import_QueryErrorResetBoundary.useQueryErrorResetBoundary,
		useSuspenseInfiniteQuery: () => import_useSuspenseInfiniteQuery.useSuspenseInfiniteQuery,
		useSuspenseQueries: () => import_useSuspenseQueries.useSuspenseQueries,
		useSuspenseQuery: () => import_useSuspenseQuery.useSuspenseQuery
		});
		module.exports = __toCommonJS(index_exports);
		__reExport(index_exports, require("@tanstack/query-core"), module.exports);
		__reExport(index_exports, require("./types.cjs"), module.exports);
		var import_useQueries = require("./useQueries.cjs");
		var import_useQuery = require("./useQuery.cjs");
		var import_useSuspenseQuery = require("./useSuspenseQuery.cjs");
		var import_useSuspenseInfiniteQuery = require("./useSuspenseInfiniteQuery.cjs");
		var import_useSuspenseQueries = require("./useSuspenseQueries.cjs");
		var import_usePrefetchQuery = require("./usePrefetchQuery.cjs");
		var import_usePrefetchInfiniteQuery = require("./usePrefetchInfiniteQuery.cjs");
		var import_queryOptions = require("./queryOptions.cjs");
		var import_infiniteQueryOptions = require("./infiniteQueryOptions.cjs");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var import_HydrationBoundary = require("./HydrationBoundary.cjs");
		var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		var import_useIsFetching = require("./useIsFetching.cjs");
		var import_useMutationState = require("./useMutationState.cjs");
		var import_useMutation = require("./useMutation.cjs");
		var import_mutationOptions = require("./mutationOptions.cjs");
		var import_useInfiniteQuery = require("./useInfiniteQuery.cjs");
		var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		HydrationBoundary,
		IsRestoringProvider,
		QueryClientContext,
		QueryClientProvider,
		QueryErrorResetBoundary,
		infiniteQueryOptions,
		mutationOptions,
		queryOptions,
		useInfiniteQuery,
		useIsFetching,
		useIsMutating,
		useIsRestoring,
		useMutation,
		useMutationState,
		usePrefetchInfiniteQuery,
		usePrefetchQuery,
		useQueries,
		useQuery,
		useQueryClient,
		useQueryErrorResetBoundary,
		useSuspenseInfiniteQuery,
		useSuspenseQueries,
		useSuspenseQuery,
		...require("@tanstack/query-core"),
		...require("./types.cjs")
		});
		//# sourceMappingURL=index.cjs.map

+1

-1

build/modern/index.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,0BAAc,iCAHd;AAMA,0BAAc,wBANd;AAOA,wBAA2B;AAE3B,sBAAyB;AACzB,8BAAiC;AACjC,sCAAyC;AACzC,gCAAmC;AAKnC,8BAAiC;AACjC,sCAAyC;AACzC,0BAA6B;AAM7B,kCAAqC;AAMrC,iCAIO;AAGP,+BAAkC;AAQlC,qCAGO;AACP,2BAA8B;AAC9B,8BAAgD;AAChD,yBAA4B;AAC5B,6BAAgC;AAChC,8BAAiC;AACjC,iCAAoD;","names":[]}
		{"version":3,"file":"index.cjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport type * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":""}

+21

-205

build/modern/index.d.cts

		@@ -1,205 +0,21 @@
		export { useQueries } from './_tsup-dts-rollup.cjs';
		export { QueriesResults } from './_tsup-dts-rollup.cjs';
		export { QueriesOptions } from './_tsup-dts-rollup.cjs';
		export { useQuery } from './_tsup-dts-rollup.cjs';
		export { useSuspenseQuery } from './_tsup-dts-rollup.cjs';
		export { useSuspenseInfiniteQuery } from './_tsup-dts-rollup.cjs';
		export { useSuspenseQueries } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesResults } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesOptions } from './_tsup-dts-rollup.cjs';
		export { usePrefetchQuery } from './_tsup-dts-rollup.cjs';
		export { usePrefetchInfiniteQuery } from './_tsup-dts-rollup.cjs';
		export { queryOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenOptions } from './_tsup-dts-rollup.cjs';
		export { infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.cjs';
		export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.cjs';
		export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.cjs';
		export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryProps_alias_1 as QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { HydrationBoundary_alias_1 as HydrationBoundary } from './_tsup-dts-rollup.cjs';
		export { HydrationBoundaryProps_alias_1 as HydrationBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { QueryErrorClearResetFunction_alias_1 as QueryErrorClearResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorIsResetFunction_alias_1 as QueryErrorIsResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryFunction_alias_1 as QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetFunction_alias_1 as QueryErrorResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundary_alias_1 as QueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		export { useQueryErrorResetBoundary_alias_1 as useQueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		export { useIsFetching } from './_tsup-dts-rollup.cjs';
		export { useIsMutating } from './_tsup-dts-rollup.cjs';
		export { useMutationState } from './_tsup-dts-rollup.cjs';
		export { useMutation } from './_tsup-dts-rollup.cjs';
		export { mutationOptions } from './_tsup-dts-rollup.cjs';
		export { useInfiniteQuery } from './_tsup-dts-rollup.cjs';
		export { useIsRestoring_alias_1 as useIsRestoring } from './_tsup-dts-rollup.cjs';
		export { IsRestoringProvider_alias_1 as IsRestoringProvider } from './_tsup-dts-rollup.cjs';
		export { focusManager } from './_tsup-dts-rollup.cjs';
		export { environmentManager } from './_tsup-dts-rollup.cjs';
		export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.cjs';
		export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.cjs';
		export { dehydrate } from './_tsup-dts-rollup.cjs';
		export { hydrate } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserver } from './_tsup-dts-rollup.cjs';
		export { MutationCache } from './_tsup-dts-rollup.cjs';
		export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
		export { MutationObserver } from './_tsup-dts-rollup.cjs';
		export { defaultScheduler } from './_tsup-dts-rollup.cjs';
		export { notifyManager } from './_tsup-dts-rollup.cjs';
		export { onlineManager } from './_tsup-dts-rollup.cjs';
		export { QueriesObserver } from './_tsup-dts-rollup.cjs';
		export { QueryCache } from './_tsup-dts-rollup.cjs';
		export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
		export { QueryClient } from './_tsup-dts-rollup.cjs';
		export { QueryObserver } from './_tsup-dts-rollup.cjs';
		export { CancelledError } from './_tsup-dts-rollup.cjs';
		export { isCancelledError } from './_tsup-dts-rollup.cjs';
		export { timeoutManager } from './_tsup-dts-rollup.cjs';
		export { ManagedTimerId } from './_tsup-dts-rollup.cjs';
		export { TimeoutCallback } from './_tsup-dts-rollup.cjs';
		export { TimeoutProvider } from './_tsup-dts-rollup.cjs';
		export { hashKey } from './_tsup-dts-rollup.cjs';
		export { isServer } from './_tsup-dts-rollup.cjs';
		export { keepPreviousData } from './_tsup-dts-rollup.cjs';
		export { matchMutation } from './_tsup-dts-rollup.cjs';
		export { matchQuery } from './_tsup-dts-rollup.cjs';
		export { noop } from './_tsup-dts-rollup.cjs';
		export { partialMatchKey } from './_tsup-dts-rollup.cjs';
		export { replaceEqualDeep } from './_tsup-dts-rollup.cjs';
		export { shouldThrowError } from './_tsup-dts-rollup.cjs';
		export { skipToken } from './_tsup-dts-rollup.cjs';
		export { MutationFilters } from './_tsup-dts-rollup.cjs';
		export { QueryFilters } from './_tsup-dts-rollup.cjs';
		export { SkipToken } from './_tsup-dts-rollup.cjs';
		export { Updater } from './_tsup-dts-rollup.cjs';
		export { experimental_streamedQuery } from './_tsup-dts-rollup.cjs';
		export { DehydratedState } from './_tsup-dts-rollup.cjs';
		export { DehydrateOptions } from './_tsup-dts-rollup.cjs';
		export { HydrateOptions } from './_tsup-dts-rollup.cjs';
		export { Mutation } from './_tsup-dts-rollup.cjs';
		export { MutationState } from './_tsup-dts-rollup.cjs';
		export { QueriesObserverOptions } from './_tsup-dts-rollup.cjs';
		export { Query } from './_tsup-dts-rollup.cjs';
		export { QueryState } from './_tsup-dts-rollup.cjs';
		export { NonUndefinedGuard } from './_tsup-dts-rollup.cjs';
		export { DistributiveOmit } from './_tsup-dts-rollup.cjs';
		export { OmitKeyof } from './_tsup-dts-rollup.cjs';
		export { Override } from './_tsup-dts-rollup.cjs';
		export { Register } from './_tsup-dts-rollup.cjs';
		export { DefaultError } from './_tsup-dts-rollup.cjs';
		export { QueryKey } from './_tsup-dts-rollup.cjs';
		export { dataTagSymbol } from './_tsup-dts-rollup.cjs';
		export { dataTagErrorSymbol } from './_tsup-dts-rollup.cjs';
		export { unsetMarker } from './_tsup-dts-rollup.cjs';
		export { UnsetMarker } from './_tsup-dts-rollup.cjs';
		export { AnyDataTag } from './_tsup-dts-rollup.cjs';
		export { DataTag } from './_tsup-dts-rollup.cjs';
		export { InferDataFromTag } from './_tsup-dts-rollup.cjs';
		export { InferErrorFromTag } from './_tsup-dts-rollup.cjs';
		export { QueryFunction } from './_tsup-dts-rollup.cjs';
		export { StaleTime } from './_tsup-dts-rollup.cjs';
		export { StaleTimeFunction } from './_tsup-dts-rollup.cjs';
		export { QueryBooleanOption } from './_tsup-dts-rollup.cjs';
		export { QueryPersister } from './_tsup-dts-rollup.cjs';
		export { QueryFunctionContext } from './_tsup-dts-rollup.cjs';
		export { InitialDataFunction } from './_tsup-dts-rollup.cjs';
		export { PlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
		export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
		export { QueryKeyHashFunction } from './_tsup-dts-rollup.cjs';
		export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.cjs';
		export { GetNextPageParamFunction } from './_tsup-dts-rollup.cjs';
		export { InfiniteData } from './_tsup-dts-rollup.cjs';
		export { QueryMeta } from './_tsup-dts-rollup.cjs';
		export { NetworkMode } from './_tsup-dts-rollup.cjs';
		export { NotifyOnChangeProps } from './_tsup-dts-rollup.cjs';
		export { QueryOptions } from './_tsup-dts-rollup.cjs';
		export { InitialPageParam } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.cjs';
		export { ThrowOnError } from './_tsup-dts-rollup.cjs';
		export { QueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { WithRequired } from './_tsup-dts-rollup.cjs';
		export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
		export { FetchQueryOptions } from './_tsup-dts-rollup.cjs';
		export { EnsureQueryDataOptions } from './_tsup-dts-rollup.cjs';
		export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.cjs';
		export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { ResultOptions } from './_tsup-dts-rollup.cjs';
		export { RefetchOptions } from './_tsup-dts-rollup.cjs';
		export { InvalidateQueryFilters } from './_tsup-dts-rollup.cjs';
		export { RefetchQueryFilters } from './_tsup-dts-rollup.cjs';
		export { InvalidateOptions } from './_tsup-dts-rollup.cjs';
		export { ResetOptions } from './_tsup-dts-rollup.cjs';
		export { FetchNextPageOptions } from './_tsup-dts-rollup.cjs';
		export { FetchPreviousPageOptions } from './_tsup-dts-rollup.cjs';
		export { QueryStatus } from './_tsup-dts-rollup.cjs';
		export { FetchStatus } from './_tsup-dts-rollup.cjs';
		export { QueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
		export { DefinedQueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { QueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
		export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
		export { MutationKey } from './_tsup-dts-rollup.cjs';
		export { MutationStatus } from './_tsup-dts-rollup.cjs';
		export { MutationScope } from './_tsup-dts-rollup.cjs';
		export { MutationMeta } from './_tsup-dts-rollup.cjs';
		export { MutationFunctionContext } from './_tsup-dts-rollup.cjs';
		export { MutationFunction } from './_tsup-dts-rollup.cjs';
		export { MutationOptions } from './_tsup-dts-rollup.cjs';
		export { MutationObserverOptions } from './_tsup-dts-rollup.cjs';
		export { MutateOptions } from './_tsup-dts-rollup.cjs';
		export { MutateFunction } from './_tsup-dts-rollup.cjs';
		export { MutationObserverBaseResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverIdleResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverLoadingResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverErrorResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverSuccessResult } from './_tsup-dts-rollup.cjs';
		export { MutationObserverResult } from './_tsup-dts-rollup.cjs';
		export { QueryClientConfig } from './_tsup-dts-rollup.cjs';
		export { DefaultOptions } from './_tsup-dts-rollup.cjs';
		export { CancelOptions } from './_tsup-dts-rollup.cjs';
		export { SetDataOptions } from './_tsup-dts-rollup.cjs';
		export { NotifyEventType } from './_tsup-dts-rollup.cjs';
		export { NotifyEvent } from './_tsup-dts-rollup.cjs';
		export { AnyUseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UsePrefetchQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { AnyUseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutateFunction } from './_tsup-dts-rollup.cjs';
		export { UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
		export { UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
		export { UseMutationResult } from './_tsup-dts-rollup.cjs';
		import { HydrationBoundary, HydrationBoundaryProps } from "./HydrationBoundary.cjs";
		import { IsRestoringProvider, useIsRestoring } from "./IsRestoringProvider.cjs";
		import { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient } from "./QueryClientProvider.cjs";
		import { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetFunction, useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.cjs";
		import { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
		import { QueriesOptions, QueriesResults, useQueries } from "./useQueries.cjs";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions } from "./queryOptions.cjs";
		import { useQuery } from "./useQuery.cjs";
		import { useSuspenseQuery } from "./useSuspenseQuery.cjs";
		import { useSuspenseInfiniteQuery } from "./useSuspenseInfiniteQuery.cjs";
		import { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries } from "./useSuspenseQueries.cjs";
		import { usePrefetchQuery } from "./usePrefetchQuery.cjs";
		import { usePrefetchInfiniteQuery } from "./usePrefetchInfiniteQuery.cjs";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions } from "./infiniteQueryOptions.cjs";
		import { useIsFetching } from "./useIsFetching.cjs";
		import { useIsMutating, useMutationState } from "./useMutationState.cjs";
		import { useMutation } from "./useMutation.cjs";
		import { mutationOptions } from "./mutationOptions.cjs";
		import { useInfiniteQuery } from "./useInfiniteQuery.cjs";
		export * from "@tanstack/query-core";
		export { type AnyUseBaseQueryOptions, type AnyUseInfiniteQueryOptions, type AnyUseMutationOptions, type AnyUseQueryOptions, type AnyUseSuspenseInfiniteQueryOptions, type AnyUseSuspenseQueryOptions, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, HydrationBoundary, type HydrationBoundaryProps, IsRestoringProvider, type QueriesOptions, type QueriesResults, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryErrorClearResetFunction, type QueryErrorIsResetFunction, QueryErrorResetBoundary, type QueryErrorResetBoundaryFunction, type QueryErrorResetBoundaryProps, type QueryErrorResetFunction, type SuspenseQueriesOptions, type SuspenseQueriesResults, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UnusedSkipTokenInfiniteOptions, type UnusedSkipTokenOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UsePrefetchInfiniteQueryOptions, type UsePrefetchQueryOptions, type UseQueryOptions, type UseQueryResult, type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryOptions, type UseSuspenseQueryResult, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };

+21

-205

build/modern/index.d.ts

		@@ -1,205 +0,21 @@
		export { useQueries } from './_tsup-dts-rollup.js';
		export { QueriesResults } from './_tsup-dts-rollup.js';
		export { QueriesOptions } from './_tsup-dts-rollup.js';
		export { useQuery } from './_tsup-dts-rollup.js';
		export { useSuspenseQuery } from './_tsup-dts-rollup.js';
		export { useSuspenseInfiniteQuery } from './_tsup-dts-rollup.js';
		export { useSuspenseQueries } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesResults } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesOptions } from './_tsup-dts-rollup.js';
		export { usePrefetchQuery } from './_tsup-dts-rollup.js';
		export { usePrefetchInfiniteQuery } from './_tsup-dts-rollup.js';
		export { queryOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenOptions } from './_tsup-dts-rollup.js';
		export { infiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.js';
		export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.js';
		export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.js';
		export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.js';
		export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryProps_alias_1 as QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.js';
		export { HydrationBoundary_alias_1 as HydrationBoundary } from './_tsup-dts-rollup.js';
		export { HydrationBoundaryProps_alias_1 as HydrationBoundaryProps } from './_tsup-dts-rollup.js';
		export { QueryErrorClearResetFunction_alias_1 as QueryErrorClearResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorIsResetFunction_alias_1 as QueryErrorIsResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryFunction_alias_1 as QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetFunction_alias_1 as QueryErrorResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundary_alias_1 as QueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		export { useQueryErrorResetBoundary_alias_1 as useQueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		export { useIsFetching } from './_tsup-dts-rollup.js';
		export { useIsMutating } from './_tsup-dts-rollup.js';
		export { useMutationState } from './_tsup-dts-rollup.js';
		export { useMutation } from './_tsup-dts-rollup.js';
		export { mutationOptions } from './_tsup-dts-rollup.js';
		export { useInfiniteQuery } from './_tsup-dts-rollup.js';
		export { useIsRestoring_alias_1 as useIsRestoring } from './_tsup-dts-rollup.js';
		export { IsRestoringProvider_alias_1 as IsRestoringProvider } from './_tsup-dts-rollup.js';
		export { focusManager } from './_tsup-dts-rollup.js';
		export { environmentManager } from './_tsup-dts-rollup.js';
		export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.js';
		export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.js';
		export { dehydrate } from './_tsup-dts-rollup.js';
		export { hydrate } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserver } from './_tsup-dts-rollup.js';
		export { MutationCache } from './_tsup-dts-rollup.js';
		export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.js';
		export { MutationObserver } from './_tsup-dts-rollup.js';
		export { defaultScheduler } from './_tsup-dts-rollup.js';
		export { notifyManager } from './_tsup-dts-rollup.js';
		export { onlineManager } from './_tsup-dts-rollup.js';
		export { QueriesObserver } from './_tsup-dts-rollup.js';
		export { QueryCache } from './_tsup-dts-rollup.js';
		export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.js';
		export { QueryClient } from './_tsup-dts-rollup.js';
		export { QueryObserver } from './_tsup-dts-rollup.js';
		export { CancelledError } from './_tsup-dts-rollup.js';
		export { isCancelledError } from './_tsup-dts-rollup.js';
		export { timeoutManager } from './_tsup-dts-rollup.js';
		export { ManagedTimerId } from './_tsup-dts-rollup.js';
		export { TimeoutCallback } from './_tsup-dts-rollup.js';
		export { TimeoutProvider } from './_tsup-dts-rollup.js';
		export { hashKey } from './_tsup-dts-rollup.js';
		export { isServer } from './_tsup-dts-rollup.js';
		export { keepPreviousData } from './_tsup-dts-rollup.js';
		export { matchMutation } from './_tsup-dts-rollup.js';
		export { matchQuery } from './_tsup-dts-rollup.js';
		export { noop } from './_tsup-dts-rollup.js';
		export { partialMatchKey } from './_tsup-dts-rollup.js';
		export { replaceEqualDeep } from './_tsup-dts-rollup.js';
		export { shouldThrowError } from './_tsup-dts-rollup.js';
		export { skipToken } from './_tsup-dts-rollup.js';
		export { MutationFilters } from './_tsup-dts-rollup.js';
		export { QueryFilters } from './_tsup-dts-rollup.js';
		export { SkipToken } from './_tsup-dts-rollup.js';
		export { Updater } from './_tsup-dts-rollup.js';
		export { experimental_streamedQuery } from './_tsup-dts-rollup.js';
		export { DehydratedState } from './_tsup-dts-rollup.js';
		export { DehydrateOptions } from './_tsup-dts-rollup.js';
		export { HydrateOptions } from './_tsup-dts-rollup.js';
		export { Mutation } from './_tsup-dts-rollup.js';
		export { MutationState } from './_tsup-dts-rollup.js';
		export { QueriesObserverOptions } from './_tsup-dts-rollup.js';
		export { Query } from './_tsup-dts-rollup.js';
		export { QueryState } from './_tsup-dts-rollup.js';
		export { NonUndefinedGuard } from './_tsup-dts-rollup.js';
		export { DistributiveOmit } from './_tsup-dts-rollup.js';
		export { OmitKeyof } from './_tsup-dts-rollup.js';
		export { Override } from './_tsup-dts-rollup.js';
		export { Register } from './_tsup-dts-rollup.js';
		export { DefaultError } from './_tsup-dts-rollup.js';
		export { QueryKey } from './_tsup-dts-rollup.js';
		export { dataTagSymbol } from './_tsup-dts-rollup.js';
		export { dataTagErrorSymbol } from './_tsup-dts-rollup.js';
		export { unsetMarker } from './_tsup-dts-rollup.js';
		export { UnsetMarker } from './_tsup-dts-rollup.js';
		export { AnyDataTag } from './_tsup-dts-rollup.js';
		export { DataTag } from './_tsup-dts-rollup.js';
		export { InferDataFromTag } from './_tsup-dts-rollup.js';
		export { InferErrorFromTag } from './_tsup-dts-rollup.js';
		export { QueryFunction } from './_tsup-dts-rollup.js';
		export { StaleTime } from './_tsup-dts-rollup.js';
		export { StaleTimeFunction } from './_tsup-dts-rollup.js';
		export { QueryBooleanOption } from './_tsup-dts-rollup.js';
		export { QueryPersister } from './_tsup-dts-rollup.js';
		export { QueryFunctionContext } from './_tsup-dts-rollup.js';
		export { InitialDataFunction } from './_tsup-dts-rollup.js';
		export { PlaceholderDataFunction } from './_tsup-dts-rollup.js';
		export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.js';
		export { QueryKeyHashFunction } from './_tsup-dts-rollup.js';
		export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.js';
		export { GetNextPageParamFunction } from './_tsup-dts-rollup.js';
		export { InfiniteData } from './_tsup-dts-rollup.js';
		export { QueryMeta } from './_tsup-dts-rollup.js';
		export { NetworkMode } from './_tsup-dts-rollup.js';
		export { NotifyOnChangeProps } from './_tsup-dts-rollup.js';
		export { QueryOptions } from './_tsup-dts-rollup.js';
		export { InitialPageParam } from './_tsup-dts-rollup.js';
		export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.js';
		export { ThrowOnError } from './_tsup-dts-rollup.js';
		export { QueryObserverOptions } from './_tsup-dts-rollup.js';
		export { WithRequired } from './_tsup-dts-rollup.js';
		export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
		export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
		export { FetchQueryOptions } from './_tsup-dts-rollup.js';
		export { EnsureQueryDataOptions } from './_tsup-dts-rollup.js';
		export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.js';
		export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { ResultOptions } from './_tsup-dts-rollup.js';
		export { RefetchOptions } from './_tsup-dts-rollup.js';
		export { InvalidateQueryFilters } from './_tsup-dts-rollup.js';
		export { RefetchQueryFilters } from './_tsup-dts-rollup.js';
		export { InvalidateOptions } from './_tsup-dts-rollup.js';
		export { ResetOptions } from './_tsup-dts-rollup.js';
		export { FetchNextPageOptions } from './_tsup-dts-rollup.js';
		export { FetchPreviousPageOptions } from './_tsup-dts-rollup.js';
		export { QueryStatus } from './_tsup-dts-rollup.js';
		export { FetchStatus } from './_tsup-dts-rollup.js';
		export { QueryObserverBaseResult } from './_tsup-dts-rollup.js';
		export { QueryObserverPendingResult } from './_tsup-dts-rollup.js';
		export { QueryObserverLoadingResult } from './_tsup-dts-rollup.js';
		export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
		export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
		export { QueryObserverSuccessResult } from './_tsup-dts-rollup.js';
		export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
		export { DefinedQueryObserverResult } from './_tsup-dts-rollup.js';
		export { QueryObserverResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
		export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
		export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
		export { MutationKey } from './_tsup-dts-rollup.js';
		export { MutationStatus } from './_tsup-dts-rollup.js';
		export { MutationScope } from './_tsup-dts-rollup.js';
		export { MutationMeta } from './_tsup-dts-rollup.js';
		export { MutationFunctionContext } from './_tsup-dts-rollup.js';
		export { MutationFunction } from './_tsup-dts-rollup.js';
		export { MutationOptions } from './_tsup-dts-rollup.js';
		export { MutationObserverOptions } from './_tsup-dts-rollup.js';
		export { MutateOptions } from './_tsup-dts-rollup.js';
		export { MutateFunction } from './_tsup-dts-rollup.js';
		export { MutationObserverBaseResult } from './_tsup-dts-rollup.js';
		export { MutationObserverIdleResult } from './_tsup-dts-rollup.js';
		export { MutationObserverLoadingResult } from './_tsup-dts-rollup.js';
		export { MutationObserverErrorResult } from './_tsup-dts-rollup.js';
		export { MutationObserverSuccessResult } from './_tsup-dts-rollup.js';
		export { MutationObserverResult } from './_tsup-dts-rollup.js';
		export { QueryClientConfig } from './_tsup-dts-rollup.js';
		export { DefaultOptions } from './_tsup-dts-rollup.js';
		export { CancelOptions } from './_tsup-dts-rollup.js';
		export { SetDataOptions } from './_tsup-dts-rollup.js';
		export { NotifyEventType } from './_tsup-dts-rollup.js';
		export { NotifyEvent } from './_tsup-dts-rollup.js';
		export { AnyUseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UsePrefetchQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryResult } from './_tsup-dts-rollup.js';
		export { UseQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseQueryResult } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { AnyUseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutateFunction } from './_tsup-dts-rollup.js';
		export { UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
		export { UseBaseMutationResult } from './_tsup-dts-rollup.js';
		export { UseMutationResult } from './_tsup-dts-rollup.js';
		import { HydrationBoundary, HydrationBoundaryProps } from "./HydrationBoundary.js";
		import { IsRestoringProvider, useIsRestoring } from "./IsRestoringProvider.js";
		import { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient } from "./QueryClientProvider.js";
		import { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetFunction, useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
		import { QueriesOptions, QueriesResults, useQueries } from "./useQueries.js";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions } from "./queryOptions.js";
		import { useQuery } from "./useQuery.js";
		import { useSuspenseQuery } from "./useSuspenseQuery.js";
		import { useSuspenseInfiniteQuery } from "./useSuspenseInfiniteQuery.js";
		import { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries } from "./useSuspenseQueries.js";
		import { usePrefetchQuery } from "./usePrefetchQuery.js";
		import { usePrefetchInfiniteQuery } from "./usePrefetchInfiniteQuery.js";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions } from "./infiniteQueryOptions.js";
		import { useIsFetching } from "./useIsFetching.js";
		import { useIsMutating, useMutationState } from "./useMutationState.js";
		import { useMutation } from "./useMutation.js";
		import { mutationOptions } from "./mutationOptions.js";
		import { useInfiniteQuery } from "./useInfiniteQuery.js";
		export * from "@tanstack/query-core";
		export { type AnyUseBaseQueryOptions, type AnyUseInfiniteQueryOptions, type AnyUseMutationOptions, type AnyUseQueryOptions, type AnyUseSuspenseInfiniteQueryOptions, type AnyUseSuspenseQueryOptions, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, HydrationBoundary, type HydrationBoundaryProps, IsRestoringProvider, type QueriesOptions, type QueriesResults, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryErrorClearResetFunction, type QueryErrorIsResetFunction, QueryErrorResetBoundary, type QueryErrorResetBoundaryFunction, type QueryErrorResetBoundaryProps, type QueryErrorResetFunction, type SuspenseQueriesOptions, type SuspenseQueriesResults, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UnusedSkipTokenInfiniteOptions, type UnusedSkipTokenOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UsePrefetchInfiniteQueryOptions, type UsePrefetchQueryOptions, type UseQueryOptions, type UseQueryResult, type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryOptions, type UseSuspenseQueryResult, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };

+10

-39

build/modern/index.js

		@@ -1,4 +0,5 @@
		// src/index.ts
		export * from "@tanstack/query-core";
		export * from "./types.js";
		import { QueryClientContext, QueryClientProvider, useQueryClient } from "./QueryClientProvider.js";
		import { HydrationBoundary } from "./HydrationBoundary.js";
		import { IsRestoringProvider, useIsRestoring } from "./IsRestoringProvider.js";
		import { QueryErrorResetBoundary, useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import { useQueries } from "./useQueries.js";
		@@ -13,12 +14,2 @@ import { useQuery } from "./useQuery.js";
		import { infiniteQueryOptions } from "./infiniteQueryOptions.js";
		import {
		QueryClientContext,
		QueryClientProvider,
		useQueryClient
		} from "./QueryClientProvider.js";
		import { HydrationBoundary } from "./HydrationBoundary.js";
		import {
		QueryErrorResetBoundary,
		useQueryErrorResetBoundary
		} from "./QueryErrorResetBoundary.js";
		import { useIsFetching } from "./useIsFetching.js";
		@@ -29,28 +20,8 @@ import { useIsMutating, useMutationState } from "./useMutationState.js";
		import { useInfiniteQuery } from "./useInfiniteQuery.js";
		import { useIsRestoring, IsRestoringProvider } from "./IsRestoringProvider.js";
		export {
		HydrationBoundary,
		IsRestoringProvider,
		QueryClientContext,
		QueryClientProvider,
		QueryErrorResetBoundary,
		infiniteQueryOptions,
		mutationOptions,
		queryOptions,
		useInfiniteQuery,
		useIsFetching,
		useIsMutating,
		useIsRestoring,
		useMutation,
		useMutationState,
		usePrefetchInfiniteQuery,
		usePrefetchQuery,
		useQueries,
		useQuery,
		useQueryClient,
		useQueryErrorResetBoundary,
		useSuspenseInfiniteQuery,
		useSuspenseQueries,
		useSuspenseQuery
		};
		export * from "@tanstack/query-core";
		//#region src/index.ts
		/* istanbul ignore file */
		//#endregion
		export { HydrationBoundary, IsRestoringProvider, QueryClientContext, QueryClientProvider, QueryErrorResetBoundary, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery };

		//# sourceMappingURL=index.js.map

+1

-1

build/modern/index.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":";AAGA,cAAc;AAGd,cAAc;AACd,SAAS,kBAAkB;AAE3B,SAAS,gBAAgB;AACzB,SAAS,wBAAwB;AACjC,SAAS,gCAAgC;AACzC,SAAS,0BAA0B;AAKnC,SAAS,wBAAwB;AACjC,SAAS,gCAAgC;AACzC,SAAS,oBAAoB;AAM7B,SAAS,4BAA4B;AAMrC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGP,SAAS,yBAAyB;AAQlC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B,SAAS,eAAe,wBAAwB;AAChD,SAAS,mBAAmB;AAC5B,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;AACjC,SAAS,gBAAgB,2BAA2B;","names":[]}
		{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/* istanbul ignore file /\n\n// Re-export core\nexport from '@tanstack/query-core'\n\n// React Query\nexport type * from './types'\nexport { useQueries } from './useQueries'\nexport type { QueriesResults, QueriesOptions } from './useQueries'\nexport { useQuery } from './useQuery'\nexport { useSuspenseQuery } from './useSuspenseQuery'\nexport { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'\nexport { useSuspenseQueries } from './useSuspenseQueries'\nexport type {\n SuspenseQueriesResults,\n SuspenseQueriesOptions,\n} from './useSuspenseQueries'\nexport { usePrefetchQuery } from './usePrefetchQuery'\nexport { usePrefetchInfiniteQuery } from './usePrefetchInfiniteQuery'\nexport { queryOptions } from './queryOptions'\nexport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n UnusedSkipTokenOptions,\n} from './queryOptions'\nexport { infiniteQueryOptions } from './infiniteQueryOptions'\nexport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n UnusedSkipTokenInfiniteOptions,\n} from './infiniteQueryOptions'\nexport {\n QueryClientContext,\n QueryClientProvider,\n useQueryClient,\n} from './QueryClientProvider'\nexport type { QueryClientProviderProps } from './QueryClientProvider'\nexport type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary'\nexport { HydrationBoundary } from './HydrationBoundary'\nexport type { HydrationBoundaryProps } from './HydrationBoundary'\nexport type {\n QueryErrorClearResetFunction,\n QueryErrorIsResetFunction,\n QueryErrorResetBoundaryFunction,\n QueryErrorResetFunction,\n} from './QueryErrorResetBoundary'\nexport {\n QueryErrorResetBoundary,\n useQueryErrorResetBoundary,\n} from './QueryErrorResetBoundary'\nexport { useIsFetching } from './useIsFetching'\nexport { useIsMutating, useMutationState } from './useMutationState'\nexport { useMutation } from './useMutation'\nexport { mutationOptions } from './mutationOptions'\nexport { useInfiniteQuery } from './useInfiniteQuery'\nexport { useIsRestoring, IsRestoringProvider } from './IsRestoringProvider'\n"],"mappings":""}

+6

-30

build/modern/infiniteQueryOptions.cjs

		@@ -1,33 +0,9 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/infiniteQueryOptions.ts
		var infiniteQueryOptions_exports = {};
		__export(infiniteQueryOptions_exports, {
		infiniteQueryOptions: () => infiniteQueryOptions
		});
		module.exports = __toCommonJS(infiniteQueryOptions_exports);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/infiniteQueryOptions.ts
		function infiniteQueryOptions(options) {
		return options;
		return options;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		infiniteQueryOptions
		});
		//#endregion
		exports.infiniteQueryOptions = infiniteQueryOptions;

		//# sourceMappingURL=infiniteQueryOptions.cjs.map

+1

-1

build/modern/infiniteQueryOptions.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkJO,SAAS,qBAAqB,SAAkB;AACrD,SAAO;AACT;","names":[]}
		{"version":3,"file":"infiniteQueryOptions.cjs","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;AA+IA,SAAgB,qBAAqB,SAAkB;CACrD,OAAO;AACT"}

+18

-4

build/modern/infiniteQueryOptions.d.cts

		@@ -1,4 +0,18 @@
		export { infiniteQueryOptions_alias_1 as infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataInfiniteOptions_alias_1 as UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenInfiniteOptions_alias_1 as UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataInfiniteOptions_alias_1 as DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
		import { UseInfiniteQueryOptions } from "./types.cjs";
		import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/infiniteQueryOptions.d.ts
		type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		//#endregion
		export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
		//# sourceMappingURL=infiniteQueryOptions.d.cts.map

+18

-4

build/modern/infiniteQueryOptions.d.ts

		@@ -1,4 +0,18 @@
		export { infiniteQueryOptions_alias_1 as infiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataInfiniteOptions_alias_1 as UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenInfiniteOptions_alias_1 as UnusedSkipTokenInfiniteOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataInfiniteOptions_alias_1 as DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
		import { UseInfiniteQueryOptions } from "./types.js";
		import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/infiniteQueryOptions.d.ts
		type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		//#endregion
		export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
		//# sourceMappingURL=infiniteQueryOptions.d.ts.map

+5

-5

build/modern/infiniteQueryOptions.js

		@@ -1,8 +0,8 @@
		// src/infiniteQueryOptions.ts
		//#region src/infiniteQueryOptions.ts
		function infiniteQueryOptions(options) {
		return options;
		return options;
		}
		export {
		infiniteQueryOptions
		};
		//#endregion
		export { infiniteQueryOptions };

		//# sourceMappingURL=infiniteQueryOptions.js.map

+1

-1

build/modern/infiniteQueryOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n}\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AAkJO,SAAS,qBAAqB,SAAkB;AACrD,SAAO;AACT;","names":[]}
		{"version":3,"file":"infiniteQueryOptions.js","names":[],"sources":["../../src/infiniteQueryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n \| undefined\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| InitialDataFunction<\n NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>\n \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)\n \| undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> &\n QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AA+IA,SAAgB,qBAAqB,SAAkB;CACrD,OAAO;AACT"}

+11

-44

build/modern/IsRestoringProvider.cjs

		@@ -1,47 +0,14 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		//#region src/IsRestoringProvider.ts
		const IsRestoringContext = react.createContext(false);
		const useIsRestoring = () => react.useContext(IsRestoringContext);
		const IsRestoringProvider = IsRestoringContext.Provider;
		//#endregion
		exports.IsRestoringProvider = IsRestoringProvider;
		exports.useIsRestoring = useIsRestoring;

		// src/IsRestoringProvider.ts
		var IsRestoringProvider_exports = {};
		__export(IsRestoringProvider_exports, {
		IsRestoringProvider: () => IsRestoringProvider,
		useIsRestoring: () => useIsRestoring
		});
		module.exports = __toCommonJS(IsRestoringProvider_exports);
		var React = __toESM(require("react"), 1);
		var IsRestoringContext = React.createContext(false);
		var useIsRestoring = () => React.useContext(IsRestoringContext);
		var IsRestoringProvider = IsRestoringContext.Provider;
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		IsRestoringProvider,
		useIsRestoring
		});
		//# sourceMappingURL=IsRestoringProvider.cjs.map

+1

-1

build/modern/IsRestoringProvider.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,IAAM,qBAA2B,oBAAc,KAAK;AAE7C,IAAM,iBAAiB,MAAY,iBAAW,kBAAkB;AAChE,IAAM,sBAAsB,mBAAmB;","names":[]}
		{"version":3,"file":"IsRestoringProvider.cjs","names":["React"],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;;;;AAGA,MAAM,qBAAqBA,MAAM,cAAc,KAAK;AAEpD,MAAa,uBAAuBA,MAAM,WAAW,kBAAkB;AACvE,MAAa,sBAAsB,mBAAmB"}

+7

-2

build/modern/IsRestoringProvider.d.cts

		@@ -1,2 +0,7 @@
		export { useIsRestoring } from './_tsup-dts-rollup.cjs';
		export { IsRestoringProvider } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		//#region src/IsRestoringProvider.d.ts
		declare const useIsRestoring: () => boolean;
		declare const IsRestoringProvider: React.Provider<boolean>;
		//#endregion
		export { IsRestoringProvider, useIsRestoring };
		//# sourceMappingURL=IsRestoringProvider.d.cts.map

+7

-2

build/modern/IsRestoringProvider.d.ts

		@@ -1,2 +0,7 @@
		export { useIsRestoring } from './_tsup-dts-rollup.js';
		export { IsRestoringProvider } from './_tsup-dts-rollup.js';
		import * as React from "react";
		//#region src/IsRestoringProvider.d.ts
		declare const useIsRestoring: () => boolean;
		declare const IsRestoringProvider: React.Provider<boolean>;
		//#endregion
		export { IsRestoringProvider, useIsRestoring };
		//# sourceMappingURL=IsRestoringProvider.d.ts.map

+7

-9

build/modern/IsRestoringProvider.js

		"use client";
		import * as React from "react";
		//#region src/IsRestoringProvider.ts
		const IsRestoringContext = React.createContext(false);
		const useIsRestoring = () => React.useContext(IsRestoringContext);
		const IsRestoringProvider = IsRestoringContext.Provider;
		//#endregion
		export { IsRestoringProvider, useIsRestoring };

		// src/IsRestoringProvider.ts
		import * as React from "react";
		var IsRestoringContext = React.createContext(false);
		var useIsRestoring = () => React.useContext(IsRestoringContext);
		var IsRestoringProvider = IsRestoringContext.Provider;
		export {
		IsRestoringProvider,
		useIsRestoring
		};
		//# sourceMappingURL=IsRestoringProvider.js.map

+1

-1

build/modern/IsRestoringProvider.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,IAAM,qBAA2B,oBAAc,KAAK;AAE7C,IAAM,iBAAiB,MAAY,iBAAW,kBAAkB;AAChE,IAAM,sBAAsB,mBAAmB;","names":[]}
		{"version":3,"file":"IsRestoringProvider.js","names":[],"sources":["../../src/IsRestoringProvider.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n"],"mappings":";;;AAGA,MAAM,qBAAqB,MAAM,cAAc,KAAK;AAEpD,MAAa,uBAAuB,MAAM,WAAW,kBAAkB;AACvE,MAAa,sBAAsB,mBAAmB"}

+6

-30

build/modern/mutationOptions.cjs

		@@ -1,33 +0,9 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/mutationOptions.ts
		var mutationOptions_exports = {};
		__export(mutationOptions_exports, {
		mutationOptions: () => mutationOptions
		});
		module.exports = __toCommonJS(mutationOptions_exports);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/mutationOptions.ts
		function mutationOptions(options) {
		return options;
		return options;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		mutationOptions
		});
		//#endregion
		exports.mutationOptions = mutationOptions;

		//# sourceMappingURL=mutationOptions.cjs.map

+1

-1

build/modern/mutationOptions.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BO,SAAS,gBAMd,SACgE;AAChE,SAAO;AACT;","names":[]}
		{"version":3,"file":"mutationOptions.cjs","names":[],"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";;AA+BA,SAAgB,gBAMd,SACgE;CAChE,OAAO;AACT"}

+8

-1

build/modern/mutationOptions.d.cts

		@@ -1,1 +0,8 @@
		export { mutationOptions_alias_1 as mutationOptions } from './_tsup-dts-rollup.cjs';
		import { UseMutationOptions } from "./types.cjs";
		import { DefaultError, WithRequired } from "@tanstack/query-core";
		//#region src/mutationOptions.d.ts
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		//#endregion
		export { mutationOptions };
		//# sourceMappingURL=mutationOptions.d.cts.map

+8

-1

build/modern/mutationOptions.d.ts

		@@ -1,1 +0,8 @@
		export { mutationOptions_alias_1 as mutationOptions } from './_tsup-dts-rollup.js';
		import { UseMutationOptions } from "./types.js";
		import { DefaultError, WithRequired } from "@tanstack/query-core";
		//#region src/mutationOptions.d.ts
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		//#endregion
		export { mutationOptions };
		//# sourceMappingURL=mutationOptions.d.ts.map

+5

-5

build/modern/mutationOptions.js

		@@ -1,8 +0,8 @@
		// src/mutationOptions.ts
		//#region src/mutationOptions.ts
		function mutationOptions(options) {
		return options;
		return options;
		}
		export {
		mutationOptions
		};
		//#endregion
		export { mutationOptions };

		//# sourceMappingURL=mutationOptions.js.map

+1

-1

build/modern/mutationOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";AA+BO,SAAS,gBAMd,SACgE;AAChE,SAAO;AACT;","names":[]}
		{"version":3,"file":"mutationOptions.js","names":[],"sources":["../../src/mutationOptions.ts"],"sourcesContent":["import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n): UseMutationOptions<TData, TError, TVariables, TOnMutateResult> {\n return options\n}\n"],"mappings":";AA+BA,SAAgB,gBAMd,SACgE;CAChE,OAAO;AACT"}

+27

-67

build/modern/QueryClientProvider.cjs

		@@ -1,72 +0,32 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let react_jsx_runtime = require("react/jsx-runtime");
		//#region src/QueryClientProvider.tsx
		const QueryClientContext = react.createContext(void 0);
		const useQueryClient = (queryClient) => {
		const client = react.useContext(QueryClientContext);
		if (queryClient) return queryClient;
		if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
		return client;
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		const QueryClientProvider = ({ client, children }) => {
		react.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(QueryClientContext.Provider, {
		value: client,
		children
		});
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		//#endregion
		exports.QueryClientContext = QueryClientContext;
		exports.QueryClientProvider = QueryClientProvider;
		exports.useQueryClient = useQueryClient;

		// src/QueryClientProvider.tsx
		var QueryClientProvider_exports = {};
		__export(QueryClientProvider_exports, {
		QueryClientContext: () => QueryClientContext,
		QueryClientProvider: () => QueryClientProvider,
		useQueryClient: () => useQueryClient
		});
		module.exports = __toCommonJS(QueryClientProvider_exports);
		var React = __toESM(require("react"), 1);
		var import_jsx_runtime = require("react/jsx-runtime");
		var QueryClientContext = React.createContext(
		void 0
		);
		var useQueryClient = (queryClient) => {
		const client = React.useContext(QueryClientContext);
		if (queryClient) {
		return queryClient;
		}
		if (!client) {
		throw new Error("No QueryClient set, use QueryClientProvider to set one");
		}
		return client;
		};
		var QueryClientProvider = ({
		client,
		children
		}) => {
		React.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children });
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		QueryClientContext,
		QueryClientProvider,
		useQueryClient
		});
		//# sourceMappingURL=QueryClientProvider.cjs.map

+1

-1

build/modern/QueryClientProvider.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAuCnB;AAnCG,IAAM,qBAA2B;AAAA,EACtC;AACF;AAEO,IAAM,iBAAiB,CAAC,gBAA8B;AAC3D,QAAM,SAAe,iBAAW,kBAAkB;AAElD,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,wDAAwD;AAAA,EAC1E;AAEA,SAAO;AACT;AAOO,IAAM,sBAAsB,CAAC;AAAA,EAClC;AAAA,EACA;AACF,MAAmD;AACjD,EAAM,gBAAU,MAAM;AACpB,WAAO,MAAM;AACb,WAAO,MAAM;AACX,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF,GAAG,CAAC,MAAM,CAAC;AAEX,SACE,4CAAC,mBAAmB,UAAnB,EAA4B,OAAO,QACjC,UACH;AAEJ;","names":[]}
		{"version":3,"file":"QueryClientProvider.cjs","names":["React"],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;;;;;AAKA,MAAa,qBAAqBA,MAAM,cACtC,KAAA,CACF;AAEA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,SAASA,MAAM,WAAW,kBAAkB;CAElD,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;AAOA,MAAa,uBAAuB,EAClC,QACA,eACiD;CACjD,MAAM,gBAAgB;EACpB,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,iBAAA,GAAA,kBAAA,IAAA,CAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}

+13

-4

build/modern/QueryClientProvider.d.cts

		@@ -1,4 +0,13 @@
		export { QueryClientContext } from './_tsup-dts-rollup.cjs';
		export { useQueryClient } from './_tsup-dts-rollup.cjs';
		export { QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
		export { QueryClientProvider } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		import { QueryClient } from "@tanstack/query-core";
		//#region src/QueryClientProvider.d.ts
		declare const QueryClientContext: React.Context<QueryClient \| undefined>;
		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		type QueryClientProviderProps = {
		client: QueryClient;
		children?: React.ReactNode;
		};
		declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => React.JSX.Element;
		//#endregion
		export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
		//# sourceMappingURL=QueryClientProvider.d.cts.map

+13

-4

build/modern/QueryClientProvider.d.ts

		@@ -1,4 +0,13 @@
		export { QueryClientContext } from './_tsup-dts-rollup.js';
		export { useQueryClient } from './_tsup-dts-rollup.js';
		export { QueryClientProviderProps } from './_tsup-dts-rollup.js';
		export { QueryClientProvider } from './_tsup-dts-rollup.js';
		import * as React from "react";
		import { QueryClient } from "@tanstack/query-core";
		//#region src/QueryClientProvider.d.ts
		declare const QueryClientContext: React.Context<QueryClient \| undefined>;
		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		type QueryClientProviderProps = {
		client: QueryClient;
		children?: React.ReactNode;
		};
		declare const QueryClientProvider: ({ client, children }: QueryClientProviderProps) => React.JSX.Element;
		//#endregion
		export { QueryClientContext, QueryClientProvider, QueryClientProviderProps, useQueryClient };
		//# sourceMappingURL=QueryClientProvider.d.ts.map

+21

-30

build/modern/QueryClientProvider.js

		"use client";

		// src/QueryClientProvider.tsx
		import * as React from "react";
		import { jsx } from "react/jsx-runtime";
		var QueryClientContext = React.createContext(
		void 0
		);
		var useQueryClient = (queryClient) => {
		const client = React.useContext(QueryClientContext);
		if (queryClient) {
		return queryClient;
		}
		if (!client) {
		throw new Error("No QueryClient set, use QueryClientProvider to set one");
		}
		return client;
		//#region src/QueryClientProvider.tsx
		const QueryClientContext = React.createContext(void 0);
		const useQueryClient = (queryClient) => {
		const client = React.useContext(QueryClientContext);
		if (queryClient) return queryClient;
		if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
		return client;
		};
		var QueryClientProvider = ({
		client,
		children
		}) => {
		React.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ jsx(QueryClientContext.Provider, { value: client, children });
		const QueryClientProvider = ({ client, children }) => {
		React.useEffect(() => {
		client.mount();
		return () => {
		client.unmount();
		};
		}, [client]);
		return /* @__PURE__ */ jsx(QueryClientContext.Provider, {
		value: client,
		children
		});
		};
		export {
		QueryClientContext,
		QueryClientProvider,
		useQueryClient
		};
		//#endregion
		export { QueryClientContext, QueryClientProvider, useQueryClient };

		//# sourceMappingURL=QueryClientProvider.js.map

+1

-1

build/modern/QueryClientProvider.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAuCnB;AAnCG,IAAM,qBAA2B;AAAA,EACtC;AACF;AAEO,IAAM,iBAAiB,CAAC,gBAA8B;AAC3D,QAAM,SAAe,iBAAW,kBAAkB;AAElD,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,wDAAwD;AAAA,EAC1E;AAEA,SAAO;AACT;AAOO,IAAM,sBAAsB,CAAC;AAAA,EAClC;AAAA,EACA;AACF,MAAmD;AACjD,EAAM,gBAAU,MAAM;AACpB,WAAO,MAAM;AACb,WAAO,MAAM;AACX,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF,GAAG,CAAC,MAAM,CAAC;AAEX,SACE,oBAAC,mBAAmB,UAAnB,EAA4B,OAAO,QACjC,UACH;AAEJ;","names":[]}
		{"version":3,"file":"QueryClientProvider.js","names":[],"sources":["../../src/QueryClientProvider.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext<QueryClient \| undefined>(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n <QueryClientContext.Provider value={client}>\n {children}\n </QueryClientContext.Provider>\n )\n}\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,MAAM,cACtC,KAAA,CACF;AAEA,MAAa,kBAAkB,gBAA8B;CAC3D,MAAM,SAAS,MAAM,WAAW,kBAAkB;CAElD,IAAI,aACF,OAAO;CAGT,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,wDAAwD;CAG1E,OAAO;AACT;AAOA,MAAa,uBAAuB,EAClC,QACA,eACiD;CACjD,MAAM,gBAAgB;EACpB,OAAO,MAAM;EACb,aAAa;GACX,OAAO,QAAQ;EACjB;CACF,GAAG,CAAC,MAAM,CAAC;CAEX,OACE,oBAAC,mBAAmB,UAApB;EAA6B,OAAO;EACjC;CAC0B,CAAA;AAEjC"}

+30

-62

build/modern/QueryErrorResetBoundary.cjs

		@@ -1,67 +0,35 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/QueryErrorResetBoundary.tsx
		var QueryErrorResetBoundary_exports = {};
		__export(QueryErrorResetBoundary_exports, {
		QueryErrorResetBoundary: () => QueryErrorResetBoundary,
		useQueryErrorResetBoundary: () => useQueryErrorResetBoundary
		});
		module.exports = __toCommonJS(QueryErrorResetBoundary_exports);
		var React = __toESM(require("react"), 1);
		var import_jsx_runtime = require("react/jsx-runtime");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let react_jsx_runtime = require("react/jsx-runtime");
		//#region src/QueryErrorResetBoundary.tsx
		function createValue() {
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		}
		var QueryErrorResetBoundaryContext = React.createContext(createValue());
		var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
		var QueryErrorResetBoundary = ({
		children
		}) => {
		const [value] = React.useState(() => createValue());
		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === "function" ? children(value) : children });
		const QueryErrorResetBoundaryContext = react.createContext(createValue());
		const useQueryErrorResetBoundary = () => react.useContext(QueryErrorResetBoundaryContext);
		const QueryErrorResetBoundary = ({ children }) => {
		const [value] = react.useState(() => createValue());
		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(QueryErrorResetBoundaryContext.Provider, {
		value,
		children: typeof children === "function" ? children(value) : children
		});
		};
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		QueryErrorResetBoundary,
		useQueryErrorResetBoundary
		});
		//#endregion
		exports.QueryErrorResetBoundary = QueryErrorResetBoundary;
		exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;

		//# sourceMappingURL=QueryErrorResetBoundary.cjs.map

+1

-1

build/modern/QueryErrorResetBoundary.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAkDnB;AArCJ,SAAS,cAA4C;AACnD,MAAI,UAAU;AACd,SAAO;AAAA,IACL,YAAY,MAAM;AAChB,gBAAU;AAAA,IACZ;AAAA,IACA,OAAO,MAAM;AACX,gBAAU;AAAA,IACZ;AAAA,IACA,SAAS,MAAM;AACb,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,IAAM,iCAAuC,oBAAc,YAAY,CAAC;AAIjE,IAAM,6BAA6B,MAClC,iBAAW,8BAA8B;AAY1C,IAAM,0BAA0B,CAAC;AAAA,EACtC;AACF,MAAoC;AAClC,QAAM,CAAC,KAAK,IAAU,eAAS,MAAM,YAAY,CAAC;AAClD,SACE,4CAAC,+BAA+B,UAA/B,EAAwC,OACtC,iBAAO,aAAa,aAAa,SAAS,KAAK,IAAI,UACtD;AAEJ;","names":[]}
		{"version":3,"file":"QueryErrorResetBoundary.cjs","names":["React"],"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;;;;;AAcA,SAAS,cAA4C;CACnD,IAAI,UAAU;CACd,OAAO;EACL,kBAAkB;GAChB,UAAU;EACZ;EACA,aAAa;GACX,UAAU;EACZ;EACA,eAAe;GACb,OAAO;EACT;CACF;AACF;AAEA,MAAM,iCAAiCA,MAAM,cAAc,YAAY,CAAC;AAIxE,MAAa,mCACXA,MAAM,WAAW,8BAA8B;AAYjD,MAAa,2BAA2B,EACtC,eACkC;CAClC,MAAM,CAAC,SAASA,MAAM,eAAe,YAAY,CAAC;CAClD,OACE,iBAAA,GAAA,kBAAA,IAAA,CAAC,+BAA+B,UAAhC;EAAgD;EAC7C,UAAA,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;CACb,CAAA;AAE7C"}

+19

-8

build/modern/QueryErrorResetBoundary.d.cts

		@@ -1,8 +0,19 @@
		export { QueryErrorResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorIsResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorClearResetFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryValue } from './_tsup-dts-rollup.cjs';
		export { useQueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.cjs';
		export { QueryErrorResetBoundary } from './_tsup-dts-rollup.cjs';
		import * as React from "react";
		//#region src/QueryErrorResetBoundary.d.ts
		type QueryErrorResetFunction = () => void;
		type QueryErrorIsResetFunction = () => boolean;
		type QueryErrorClearResetFunction = () => void;
		interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}
		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React.ReactNode;
		interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React.ReactNode;
		}
		declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("react/jsx-runtime").JSX.Element;
		//#endregion
		export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
		//# sourceMappingURL=QueryErrorResetBoundary.d.cts.map

+19

-8

build/modern/QueryErrorResetBoundary.d.ts

		@@ -1,8 +0,19 @@
		export { QueryErrorResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorIsResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorClearResetFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryValue } from './_tsup-dts-rollup.js';
		export { useQueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryFunction } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundaryProps } from './_tsup-dts-rollup.js';
		export { QueryErrorResetBoundary } from './_tsup-dts-rollup.js';
		import * as React from "react";
		//#region src/QueryErrorResetBoundary.d.ts
		type QueryErrorResetFunction = () => void;
		type QueryErrorIsResetFunction = () => boolean;
		type QueryErrorClearResetFunction = () => void;
		interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}
		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React.ReactNode;
		interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React.ReactNode;
		}
		declare const QueryErrorResetBoundary: ({ children }: QueryErrorResetBoundaryProps) => import("react/jsx-runtime").JSX.Element;
		//#endregion
		export { QueryErrorClearResetFunction, QueryErrorIsResetFunction, QueryErrorResetBoundary, QueryErrorResetBoundaryFunction, QueryErrorResetBoundaryProps, QueryErrorResetBoundaryValue, QueryErrorResetFunction, useQueryErrorResetBoundary };
		//# sourceMappingURL=QueryErrorResetBoundary.d.ts.map

+24

-25

build/modern/QueryErrorResetBoundary.js

		"use client";

		// src/QueryErrorResetBoundary.tsx
		import * as React from "react";
		import { jsx } from "react/jsx-runtime";
		//#region src/QueryErrorResetBoundary.tsx
		function createValue() {
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		let isReset = false;
		return {
		clearReset: () => {
		isReset = false;
		},
		reset: () => {
		isReset = true;
		},
		isReset: () => {
		return isReset;
		}
		};
		}
		var QueryErrorResetBoundaryContext = React.createContext(createValue());
		var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
		var QueryErrorResetBoundary = ({
		children
		}) => {
		const [value] = React.useState(() => createValue());
		return /* @__PURE__ */ jsx(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === "function" ? children(value) : children });
		const QueryErrorResetBoundaryContext = React.createContext(createValue());
		const useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
		const QueryErrorResetBoundary = ({ children }) => {
		const [value] = React.useState(() => createValue());
		return /* @__PURE__ */ jsx(QueryErrorResetBoundaryContext.Provider, {
		value,
		children: typeof children === "function" ? children(value) : children
		});
		};
		export {
		QueryErrorResetBoundary,
		useQueryErrorResetBoundary
		};
		//#endregion
		export { QueryErrorResetBoundary, useQueryErrorResetBoundary };

		//# sourceMappingURL=QueryErrorResetBoundary.js.map

+1

-1

build/modern/QueryErrorResetBoundary.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAkDnB;AArCJ,SAAS,cAA4C;AACnD,MAAI,UAAU;AACd,SAAO;AAAA,IACL,YAAY,MAAM;AAChB,gBAAU;AAAA,IACZ;AAAA,IACA,OAAO,MAAM;AACX,gBAAU;AAAA,IACZ;AAAA,IACA,SAAS,MAAM;AACb,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,IAAM,iCAAuC,oBAAc,YAAY,CAAC;AAIjE,IAAM,6BAA6B,MAClC,iBAAW,8BAA8B;AAY1C,IAAM,0BAA0B,CAAC;AAAA,EACtC;AACF,MAAoC;AAClC,QAAM,CAAC,KAAK,IAAU,eAAS,MAAM,YAAY,CAAC;AAClD,SACE,oBAAC,+BAA+B,UAA/B,EAAwC,OACtC,iBAAO,aAAa,aAAa,SAAS,KAAK,IAAI,UACtD;AAEJ;","names":[]}
		{"version":3,"file":"QueryErrorResetBoundary.js","names":[],"sources":["../../src/QueryErrorResetBoundary.tsx"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction \| React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n <QueryErrorResetBoundaryContext.Provider value={value}>\n {typeof children === 'function' ? children(value) : children}\n </QueryErrorResetBoundaryContext.Provider>\n )\n}\n"],"mappings":";;;;AAcA,SAAS,cAA4C;CACnD,IAAI,UAAU;CACd,OAAO;EACL,kBAAkB;GAChB,UAAU;EACZ;EACA,aAAa;GACX,UAAU;EACZ;EACA,eAAe;GACb,OAAO;EACT;CACF;AACF;AAEA,MAAM,iCAAiC,MAAM,cAAc,YAAY,CAAC;AAIxE,MAAa,mCACX,MAAM,WAAW,8BAA8B;AAYjD,MAAa,2BAA2B,EACtC,eACkC;CAClC,MAAM,CAAC,SAAS,MAAM,eAAe,YAAY,CAAC;CAClD,OACE,oBAAC,+BAA+B,UAAhC;EAAgD;EAC7C,UAAA,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;CACb,CAAA;AAE7C"}

+6

-30

build/modern/queryOptions.cjs

		@@ -1,33 +0,9 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/queryOptions.ts
		var queryOptions_exports = {};
		__export(queryOptions_exports, {
		queryOptions: () => queryOptions
		});
		module.exports = __toCommonJS(queryOptions_exports);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/queryOptions.ts
		function queryOptions(options) {
		return options;
		return options;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		queryOptions
		});
		//#endregion
		exports.queryOptions = queryOptions;

		//# sourceMappingURL=queryOptions.cjs.map

+1

-1

build/modern/queryOptions.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoFO,SAAS,aAAa,SAAkB;AAC7C,SAAO;AACT;","names":[]}
		{"version":3,"file":"queryOptions.cjs","names":[],"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";;AAiFA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}

+19

-4

build/modern/queryOptions.d.cts

		@@ -1,4 +0,19 @@
		export { queryOptions_alias_1 as queryOptions } from './_tsup-dts-rollup.cjs';
		export { UndefinedInitialDataOptions_alias_1 as UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		export { UnusedSkipTokenOptions_alias_1 as UnusedSkipTokenOptions } from './_tsup-dts-rollup.cjs';
		export { DefinedInitialDataOptions_alias_1 as DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
		import { UseQueryOptions } from "./types.cjs";
		import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/queryOptions.d.ts
		type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		//#endregion
		export { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions };
		//# sourceMappingURL=queryOptions.d.cts.map

+19

-4

build/modern/queryOptions.d.ts

		@@ -1,4 +0,19 @@
		export { queryOptions_alias_1 as queryOptions } from './_tsup-dts-rollup.js';
		export { UndefinedInitialDataOptions_alias_1 as UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		export { UnusedSkipTokenOptions_alias_1 as UnusedSkipTokenOptions } from './_tsup-dts-rollup.js';
		export { DefinedInitialDataOptions_alias_1 as DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
		import { UseQueryOptions } from "./types.js";
		import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryFunction, QueryKey, QueryKeyWithDataTag, SkipToken } from "@tanstack/query-core";
		//#region src/queryOptions.d.ts
		type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
		//#endregion
		export { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions };
		//# sourceMappingURL=queryOptions.d.ts.map

+5

-5

build/modern/queryOptions.js

		@@ -1,8 +0,8 @@
		// src/queryOptions.ts
		//#region src/queryOptions.ts
		function queryOptions(options) {
		return options;
		return options;
		}
		export {
		queryOptions
		};
		//#endregion
		export { queryOptions };

		//# sourceMappingURL=queryOptions.js.map

+1

-1

build/modern/queryOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DataTag,\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {\n queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AAoFO,SAAS,aAAa,SAAkB;AAC7C,SAAO;AACT;","names":[]}
		{"version":3,"file":"queryOptions.js","names":[],"sources":["../../src/queryOptions.ts"],"sourcesContent":["import type {\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n QueryKeyWithDataTag,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {\n initialData?:\n \| undefined\n \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>>\n \| NonUndefinedGuard<TQueryFnData>\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken \| undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {\n initialData:\n \| NonUndefinedGuard<TQueryFnData>\n \| (() => NonUndefinedGuard<TQueryFnData>)\n queryFn?: QueryFunction<TQueryFnData, TQueryKey>\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &\n QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>\n\nexport function queryOptions(options: unknown) {\n return options\n}\n"],"mappings":";AAiFA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}

+20

-55

build/modern/suspense.cjs

		@@ -1,58 +0,23 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		//#region src/suspense.ts
		const defaultThrowOnError = (_error, query) => query.state.data === void 0;
		const 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 __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		const shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
		const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
		errorResetBoundary.clearReset();
		});
		//#endregion
		exports.defaultThrowOnError = defaultThrowOnError;
		exports.ensureSuspenseTimers = ensureSuspenseTimers;
		exports.fetchOptimistic = fetchOptimistic;
		exports.shouldSuspend = shouldSuspend;

		// src/suspense.ts
		var suspense_exports = {};
		__export(suspense_exports, {
		defaultThrowOnError: () => defaultThrowOnError,
		ensureSuspenseTimers: () => ensureSuspenseTimers,
		fetchOptimistic: () => fetchOptimistic,
		shouldSuspend: () => shouldSuspend,
		willFetch: () => willFetch
		});
		module.exports = __toCommonJS(suspense_exports);
		var defaultThrowOnError = (_error, query) => query.state.data === void 0;
		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();
		});
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		defaultThrowOnError,
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend,
		willFetch
		});
		//# sourceMappingURL=suspense.cjs.map

+1

-1

build/modern/suspense.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const willFetch = (\n result: QueryObserverResult<any, any>,\n isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,IAAM,sBAAsB,CAMjC,QACA,UACG,MAAM,MAAM,SAAS;AAEnB,IAAM,uBAAuB,CAClC,qBACG;AACH,MAAI,iBAAiB,UAAU;AAG7B,UAAM,uBAAuB;AAE7B,UAAM,QAAQ,CAAC,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;AAElE,UAAM,oBAAoB,iBAAiB;AAC3C,qBAAiB,YACf,OAAO,sBAAsB,aACzB,IAAI,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;AAE7B,QAAI,OAAO,iBAAiB,WAAW,UAAU;AAC/C,uBAAiB,SAAS,KAAK;AAAA,QAC7B,iBAAiB;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,YAAY,CACvB,QACA,gBACG,OAAO,aAAa,OAAO,cAAc,CAAC;AAExC,IAAM,gBAAgB,CAC3B,kBAGA,WACG,kBAAkB,YAAY,OAAO;AAEnC,IAAM,kBAAkB,CAO7B,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,EAAE,MAAM,MAAM;AACrD,qBAAmB,WAAW;AAChC,CAAC;","names":[]}
		{"version":3,"file":"suspense.cjs","names":[],"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";;AAUA,MAAa,uBAMX,QACA,UACG,MAAM,MAAM,SAAS,KAAA;AAE1B,MAAa,wBACX,qBACG;CACH,IAAI,iBAAiB,UAAU;EAG7B,MAAM,uBAAuB;EAE7B,MAAM,SAAS,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;EAElE,MAAM,oBAAoB,iBAAiB;EAC3C,iBAAiB,YACf,OAAO,sBAAsB,cACxB,GAAG,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;EAE7B,IAAI,OAAO,iBAAiB,WAAW,UACrC,iBAAiB,SAAS,KAAK,IAC7B,iBAAiB,QACjB,oBACF;CAEJ;AACF;AAEA,MAAa,iBACX,kBAGA,WACG,kBAAkB,YAAY,OAAO;AAE1C,MAAa,mBAOX,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,CAAC,CAAC,YAAY;CACrD,mBAAmB,WAAW;AAChC,CAAC"}

+10

-5

build/modern/suspense.d.cts

		@@ -1,5 +0,10 @@
		export { defaultThrowOnError } from './_tsup-dts-rollup.cjs';
		export { ensureSuspenseTimers } from './_tsup-dts-rollup.cjs';
		export { willFetch } from './_tsup-dts-rollup.cjs';
		export { shouldSuspend } from './_tsup-dts-rollup.cjs';
		export { fetchOptimistic } from './_tsup-dts-rollup.cjs';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.cjs";
		import { DefaultError, DefaultedQueryObserverOptions, Query, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/suspense.d.ts
		declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;
		declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;
		declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;
		declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;
		//#endregion
		export { defaultThrowOnError, ensureSuspenseTimers, fetchOptimistic, shouldSuspend };
		//# sourceMappingURL=suspense.d.cts.map

+10

-5

build/modern/suspense.d.ts

		@@ -1,5 +0,10 @@
		export { defaultThrowOnError } from './_tsup-dts-rollup.js';
		export { ensureSuspenseTimers } from './_tsup-dts-rollup.js';
		export { willFetch } from './_tsup-dts-rollup.js';
		export { shouldSuspend } from './_tsup-dts-rollup.js';
		export { fetchOptimistic } from './_tsup-dts-rollup.js';
		import { QueryErrorResetBoundaryValue } from "./QueryErrorResetBoundary.js";
		import { DefaultError, DefaultedQueryObserverOptions, Query, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/suspense.d.ts
		declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;
		declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;
		declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;
		declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;
		//#endregion
		export { defaultThrowOnError, ensureSuspenseTimers, fetchOptimistic, shouldSuspend };
		//# sourceMappingURL=suspense.d.ts.map

+16

-26

build/modern/suspense.js

		@@ -1,29 +0,19 @@
		// src/suspense.ts
		var defaultThrowOnError = (_error, query) => query.state.data === void 0;
		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
		);
		}
		}
		//#region src/suspense.ts
		const defaultThrowOnError = (_error, query) => query.state.data === void 0;
		const 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();
		const shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
		const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
		errorResetBoundary.clearReset();
		});
		export {
		defaultThrowOnError,
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend,
		willFetch
		};
		//#endregion
		export { defaultThrowOnError, ensureSuspenseTimers, fetchOptimistic, shouldSuspend };

		//# sourceMappingURL=suspense.js.map

+1

-1

build/modern/suspense.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const willFetch = (\n result: QueryObserverResult<any, any>,\n isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";AAUO,IAAM,sBAAsB,CAMjC,QACA,UACG,MAAM,MAAM,SAAS;AAEnB,IAAM,uBAAuB,CAClC,qBACG;AACH,MAAI,iBAAiB,UAAU;AAG7B,UAAM,uBAAuB;AAE7B,UAAM,QAAQ,CAAC,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;AAElE,UAAM,oBAAoB,iBAAiB;AAC3C,qBAAiB,YACf,OAAO,sBAAsB,aACzB,IAAI,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;AAE7B,QAAI,OAAO,iBAAiB,WAAW,UAAU;AAC/C,uBAAiB,SAAS,KAAK;AAAA,QAC7B,iBAAiB;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,YAAY,CACvB,QACA,gBACG,OAAO,aAAa,OAAO,cAAc,CAAC;AAExC,IAAM,gBAAgB,CAC3B,kBAGA,WACG,kBAAkB,YAAY,OAAO;AAEnC,IAAM,kBAAkB,CAO7B,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,EAAE,MAAM,MAAM;AACrD,qBAAmB,WAAW;AAChC,CAAC;","names":[]}
		{"version":3,"file":"suspense.js","names":[],"sources":["../../src/suspense.ts"],"sourcesContent":["import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query<TQueryFnData, TError, TData, TQueryKey>,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number \| 'static' \| undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const shouldSuspend = (\n defaultedOptions:\n \| DefaultedQueryObserverOptions<any, any, any, any, any>\n \| undefined,\n result: QueryObserverResult<any, any>,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n"],"mappings":";AAUA,MAAa,uBAMX,QACA,UACG,MAAM,MAAM,SAAS,KAAA;AAE1B,MAAa,wBACX,qBACG;CACH,IAAI,iBAAiB,UAAU;EAG7B,MAAM,uBAAuB;EAE7B,MAAM,SAAS,UACb,UAAU,WACN,QACA,KAAK,IAAI,SAAS,sBAAsB,oBAAoB;EAElE,MAAM,oBAAoB,iBAAiB;EAC3C,iBAAiB,YACf,OAAO,sBAAsB,cACxB,GAAG,SAAS,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAC7C,MAAM,iBAAiB;EAE7B,IAAI,OAAO,iBAAiB,WAAW,UACrC,iBAAiB,SAAS,KAAK,IAC7B,iBAAiB,QACjB,oBACF;CAEJ;AACF;AAEA,MAAa,iBACX,kBAGA,WACG,kBAAkB,YAAY,OAAO;AAE1C,MAAa,mBAOX,kBAOA,UACA,uBAEA,SAAS,gBAAgB,gBAAgB,CAAC,CAAC,YAAY;CACrD,mBAAmB,WAAW;AAChC,CAAC"}

+3

-17

build/modern/types.cjs

		@@ -1,19 +0,5 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		//#region src/types.ts
		/* istanbul ignore file */
		//#endregion

		// src/types.ts
		var types_exports = {};
		module.exports = __toCommonJS(types_exports);
		//# sourceMappingURL=types.cjs.map

+1

-1

build/modern/types.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file /\n\nimport type {\n DefaultError,\n DefinedInfiniteQueryObserverResult,\n DefinedQueryObserverResult,\n DistributiveOmit,\n FetchQueryOptions,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n MutateFunction,\n MutationObserverOptions,\n MutationObserverResult,\n OmitKeyof,\n Override,\n QueryKey,\n QueryObserverOptions,\n QueryObserverResult,\n SkipToken,\n} from '@tanstack/query-core'\n\nexport type AnyUseBaseQueryOptions = UseBaseQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseBaseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n /\n subscribed?: boolean\n}\n\nexport interface UsePrefetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn'\n> {\n queryFn?: Exclude<\n FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>\nexport interface UseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n 'suspense'\n> {}\n\nexport type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<\n any,\n any,\n any,\n any\n>\nexport interface UseSuspenseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'suspense'\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n */\n subscribed?: boolean\n}\n\nexport type AnyUseSuspenseInfiniteQueryOptions =\n UseSuspenseInfiniteQueryOptions<any, any, any, any, any>\nexport interface UseSuspenseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UseBaseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = QueryObserverResult<TData, TError>\n\nexport type UseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = UseBaseQueryResult<TData, TError>\n\nexport type UseSuspenseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DistributiveOmit<\n DefinedQueryObserverResult<TData, TError>,\n 'isPlaceholderData' \| 'promise'\n>\n\nexport type DefinedUseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedQueryObserverResult<TData, TError>\n\nexport type UseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = InfiniteQueryObserverResult<TData, TError>\n\nexport type DefinedUseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedInfiniteQueryObserverResult<TData, TError>\n\nexport type UseSuspenseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = OmitKeyof<\n DefinedInfiniteQueryObserverResult<TData, TError>,\n 'isPlaceholderData' \| 'promise'\n>\n\nexport type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>\nexport interface UseMutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends OmitKeyof<\n MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n '_defaulted'\n> {}\n\nexport type UseMutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n ...args: Parameters<\n MutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n) => void\n\nexport type UseMutateAsyncFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\nexport type UseBaseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = Override<\n MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n mutateAsync: UseMutateAsyncFunction<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >\n}\n\nexport type UseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
		{"version":3,"file":"types.cjs","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file /\n\nimport type {\n DefaultError,\n DefinedInfiniteQueryObserverResult,\n DefinedQueryObserverResult,\n DistributiveOmit,\n InfiniteData,\n InfiniteQueryExecuteOptions,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n MutateFunction,\n MutationObserverOptions,\n MutationObserverResult,\n OmitKeyof,\n Override,\n QueryExecuteOptions,\n QueryKey,\n QueryObserverOptions,\n QueryObserverResult,\n SkipToken,\n} from '@tanstack/query-core'\n\nexport type AnyUseBaseQueryOptions = UseBaseQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseBaseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n /\n subscribed?: boolean\n}\n\nexport type UsePrefetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = DistributiveOmit<\n QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n QueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UsePrefetchInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = DistributiveOmit<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>\nexport interface UseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n 'suspense'\n> {}\n\nexport type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<\n any,\n any,\n any,\n any\n>\nexport interface UseSuspenseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'suspense'\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n */\n subscribed?: boolean\n}\n\nexport type AnyUseSuspenseInfiniteQueryOptions =\n UseSuspenseInfiniteQueryOptions<any, any, any, any, any>\nexport interface UseSuspenseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UseBaseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = QueryObserverResult<TData, TError>\n\nexport type UseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = UseBaseQueryResult<TData, TError>\n\nexport type UseSuspenseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DistributiveOmit<\n DefinedQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type DefinedUseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedQueryObserverResult<TData, TError>\n\nexport type UseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = InfiniteQueryObserverResult<TData, TError>\n\nexport type DefinedUseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedInfiniteQueryObserverResult<TData, TError>\n\nexport type UseSuspenseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = OmitKeyof<\n DefinedInfiniteQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>\nexport interface UseMutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends OmitKeyof<\n MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n '_defaulted'\n> {}\n\nexport type UseMutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n ...args: Parameters<\n MutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n) => void\n\nexport type UseMutateAsyncFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\nexport type UseBaseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = Override<\n MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n mutateAsync: UseMutateAsyncFunction<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >\n}\n\nexport type UseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>\n"],"mappings":""}

+54

-24

build/modern/types.d.cts

		@@ -1,24 +0,54 @@
		export { AnyUseBaseQueryOptions_alias_1 as AnyUseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryOptions_alias_1 as UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UsePrefetchQueryOptions_alias_1 as UsePrefetchQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseQueryOptions_alias_1 as AnyUseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseQueryOptions_alias_1 as UseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseQueryOptions_alias_1 as AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryOptions_alias_1 as UseSuspenseQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseInfiniteQueryOptions_alias_1 as AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryOptions_alias_1 as UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { AnyUseSuspenseInfiniteQueryOptions_alias_1 as AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryOptions_alias_1 as UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
		export { UseBaseQueryResult_alias_1 as UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseQueryResult_alias_1 as UseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseQueryResult_alias_1 as UseSuspenseQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseQueryResult_alias_1 as DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseInfiniteQueryResult_alias_1 as UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { DefinedUseInfiniteQueryResult_alias_1 as DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { UseSuspenseInfiniteQueryResult_alias_1 as UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
		export { AnyUseMutationOptions_alias_1 as AnyUseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutationOptions_alias_1 as UseMutationOptions } from './_tsup-dts-rollup.cjs';
		export { UseMutateFunction_alias_1 as UseMutateFunction } from './_tsup-dts-rollup.cjs';
		export { UseMutateAsyncFunction_alias_1 as UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
		export { UseBaseMutationResult_alias_1 as UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
		export { UseMutationResult_alias_1 as UseMutationResult } from './_tsup-dts-rollup.cjs';
		import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, DistributiveOmit, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryExecuteOptions, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken } from "@tanstack/query-core";
		//#region src/types.d.ts
		type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>['queryFn'], SkipToken>;
		};
		type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = DistributiveOmit<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		};
		type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
		type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
		type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult };
		//# sourceMappingURL=types.d.cts.map

+54

-24

build/modern/types.d.ts

		@@ -1,24 +0,54 @@
		export { AnyUseBaseQueryOptions_alias_1 as AnyUseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryOptions_alias_1 as UseBaseQueryOptions } from './_tsup-dts-rollup.js';
		export { UsePrefetchQueryOptions_alias_1 as UsePrefetchQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseQueryOptions_alias_1 as AnyUseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseQueryOptions_alias_1 as UseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseQueryOptions_alias_1 as AnyUseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryOptions_alias_1 as UseSuspenseQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseInfiniteQueryOptions_alias_1 as AnyUseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryOptions_alias_1 as UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { AnyUseSuspenseInfiniteQueryOptions_alias_1 as AnyUseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryOptions_alias_1 as UseSuspenseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
		export { UseBaseQueryResult_alias_1 as UseBaseQueryResult } from './_tsup-dts-rollup.js';
		export { UseQueryResult_alias_1 as UseQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseQueryResult_alias_1 as UseSuspenseQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseQueryResult_alias_1 as DefinedUseQueryResult } from './_tsup-dts-rollup.js';
		export { UseInfiniteQueryResult_alias_1 as UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { DefinedUseInfiniteQueryResult_alias_1 as DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { UseSuspenseInfiniteQueryResult_alias_1 as UseSuspenseInfiniteQueryResult } from './_tsup-dts-rollup.js';
		export { AnyUseMutationOptions_alias_1 as AnyUseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutationOptions_alias_1 as UseMutationOptions } from './_tsup-dts-rollup.js';
		export { UseMutateFunction_alias_1 as UseMutateFunction } from './_tsup-dts-rollup.js';
		export { UseMutateAsyncFunction_alias_1 as UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
		export { UseBaseMutationResult_alias_1 as UseBaseMutationResult } from './_tsup-dts-rollup.js';
		export { UseMutationResult_alias_1 as UseMutationResult } from './_tsup-dts-rollup.js';
		import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverResult, DistributiveOmit, InfiniteData, InfiniteQueryExecuteOptions, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, OmitKeyof, Override, QueryExecuteOptions, QueryKey, QueryObserverOptions, QueryObserverResult, SkipToken } from "@tanstack/query-core";
		//#region src/types.d.ts
		type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>['queryFn'], SkipToken>;
		};
		type UsePrefetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = DistributiveOmit<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		};
		type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
		type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>;
		type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
		type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { AnyUseBaseQueryOptions, AnyUseInfiniteQueryOptions, AnyUseMutationOptions, AnyUseQueryOptions, AnyUseSuspenseInfiniteQueryOptions, AnyUseSuspenseQueryOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, UseBaseMutationResult, UseBaseQueryOptions, UseBaseQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutateAsyncFunction, UseMutateFunction, UseMutationOptions, UseMutationResult, UsePrefetchInfiniteQueryOptions, UsePrefetchQueryOptions, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult };
		//# sourceMappingURL=types.d.ts.map

+5

-0

build/modern/types.js

		@@ -0,1 +1,6 @@
		//#region src/types.ts
		/* istanbul ignore file */
		//#endregion
		export {};

		//# sourceMappingURL=types.js.map

+1

-1

build/modern/types.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
		{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file /\n\nimport type {\n DefaultError,\n DefinedInfiniteQueryObserverResult,\n DefinedQueryObserverResult,\n DistributiveOmit,\n InfiniteData,\n InfiniteQueryExecuteOptions,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n MutateFunction,\n MutationObserverOptions,\n MutationObserverResult,\n OmitKeyof,\n Override,\n QueryExecuteOptions,\n QueryKey,\n QueryObserverOptions,\n QueryObserverResult,\n SkipToken,\n} from '@tanstack/query-core'\n\nexport type AnyUseBaseQueryOptions = UseBaseQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseBaseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n /\n subscribed?: boolean\n}\n\nexport type UsePrefetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = DistributiveOmit<\n QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n QueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UsePrefetchInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = DistributiveOmit<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n InfiniteQueryExecuteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>\nexport interface UseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,\n 'suspense'\n> {}\n\nexport type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<\n any,\n any,\n any,\n any\n>\nexport interface UseSuspenseQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],\n SkipToken\n >\n}\n\nexport type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<\n any,\n any,\n any,\n any,\n any\n>\nexport interface UseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'suspense'\n> {\n /\n Set this to `false` to unsubscribe this observer from updates to the query cache.\n * Defaults to `true`.\n */\n subscribed?: boolean\n}\n\nexport type AnyUseSuspenseInfiniteQueryOptions =\n UseSuspenseInfiniteQueryOptions<any, any, any, any, any>\nexport interface UseSuspenseInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends OmitKeyof<\n UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'\n> {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken\n >\n}\n\nexport type UseBaseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = QueryObserverResult<TData, TError>\n\nexport type UseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = UseBaseQueryResult<TData, TError>\n\nexport type UseSuspenseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DistributiveOmit<\n DefinedQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type DefinedUseQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedQueryObserverResult<TData, TError>\n\nexport type UseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = InfiniteQueryObserverResult<TData, TError>\n\nexport type DefinedUseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = DefinedInfiniteQueryObserverResult<TData, TError>\n\nexport type UseSuspenseInfiniteQueryResult<\n TData = unknown,\n TError = DefaultError,\n> = OmitKeyof<\n DefinedInfiniteQueryObserverResult<TData, TError>,\n 'isPlaceholderData'\n>\n\nexport type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>\nexport interface UseMutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends OmitKeyof<\n MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,\n '_defaulted'\n> {}\n\nexport type UseMutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n ...args: Parameters<\n MutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n) => void\n\nexport type UseMutateAsyncFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = MutateFunction<TData, TError, TVariables, TOnMutateResult>\n\nexport type UseBaseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = Override<\n MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,\n { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }\n> & {\n mutateAsync: UseMutateAsyncFunction<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >\n}\n\nexport type UseMutationResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>\n"],"mappings":""}

+50

-127

build/modern/useBaseQuery.cjs

		@@ -1,131 +0,54 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useBaseQuery.ts
		var useBaseQuery_exports = {};
		__export(useBaseQuery_exports, {
		useBaseQuery: () => useBaseQuery
		});
		module.exports = __toCommonJS(useBaseQuery_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		var import_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		const require_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		const require_suspense = require("./suspense.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useBaseQuery.ts
		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 = (0, import_IsRestoringProvider.useIsRestoring)();
		const errorResetBoundary = (0, import_QueryErrorResetBoundary.useQueryErrorResetBoundary)();
		const client = (0, import_QueryClientProvider.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`
		);
		}
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		(0, import_suspense.ensureSuspenseTimers)(defaultedOptions);
		(0, import_errorBoundaryUtils.ensurePreventErrorBoundaryRetry)(defaultedOptions, errorResetBoundary, query);
		(0, import_errorBoundaryUtils.useClearResetErrorBoundary)(errorResetBoundary);
		const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
		const [observer] = React.useState(
		() => new Observer(
		client,
		defaultedOptions
		)
		);
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)) : import_query_core.noop;
		observer.updateResult();
		return unsubscribe;
		},
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		React.useEffect(() => {
		observer.setOptions(defaultedOptions);
		}, [defaultedOptions, observer]);
		if ((0, import_suspense.shouldSuspend)(defaultedOptions, result)) {
		throw (0, import_suspense.fetchOptimistic)(defaultedOptions, observer, errorResetBoundary);
		}
		if ((0, import_errorBoundaryUtils.getHasError)({
		result,
		errorResetBoundary,
		throwOnError: defaultedOptions.throwOnError,
		query,
		suspense: defaultedOptions.suspense
		})) {
		throw result.error;
		}
		;
		client.getDefaultOptions().queries?._experimental_afterQuery?.(
		defaultedOptions,
		result
		);
		if (defaultedOptions.experimental_prefetchInRender && !import_query_core.environmentManager.isServer() && (0, import_suspense.willFetch)(result, isRestoring)) {
		const promise = isNewCacheEntry ? (
		// Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
		(0, import_suspense.fetchOptimistic)(defaultedOptions, observer, errorResetBoundary)
		) : (
		// subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
		query?.promise
		);
		promise?.catch(import_query_core.noop).finally(() => {
		observer.updateResult();
		});
		}
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		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 = require_IsRestoringProvider.useIsRestoring();
		const errorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary();
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const defaultedOptions = client.defaultQueryOptions(options);
		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`);
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		require_suspense.ensureSuspenseTimers(defaultedOptions);
		require_errorBoundaryUtils.ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
		require_errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = react.useState(() => new Observer(client, defaultedOptions));
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		react.useSyncExternalStore(react.useCallback((onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)) : _tanstack_query_core.noop;
		observer.updateResult();
		return unsubscribe;
		}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		react.useEffect(() => {
		observer.setOptions(defaultedOptions);
		}, [defaultedOptions, observer]);
		if (require_suspense.shouldSuspend(defaultedOptions, result)) throw require_suspense.fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
		if (require_errorBoundaryUtils.getHasError({
		result,
		errorResetBoundary,
		throwOnError: defaultedOptions.throwOnError,
		query,
		suspense: defaultedOptions.suspense
		})) throw result.error;
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useBaseQuery
		});
		//#endregion
		exports.useBaseQuery = useBaseQuery;

		//# sourceMappingURL=useBaseQuery.cjs.map

+1

-1

build/modern/useBaseQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { environmentManager, noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n willFetch,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n ;(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(\n defaultedOptions,\n )\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n // this needs to be invoked before creating the Observer because that can create a cache entry\n const isNewCacheEntry = !client\n .getQueryCache()\n .get(defaultedOptions.queryHash)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n ;(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(\n defaultedOptions,\n result,\n )\n\n if (\n defaultedOptions.experimental_prefetchInRender &&\n !environmentManager.isServer() &&\n willFetch(result, isRestoring)\n ) {\n const promise = isNewCacheEntry\n ? // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted\n fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n : // subscribe to the \"cache promise\" so that we can finalize the currentThenable once data comes in\n query?.promise\n\n promise?.catch(noop).finally(() => {\n // `.updateResult()` will trigger `.#currentThenable` to finalize\n observer.updateResult()\n })\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAAwD;AACxD,iCAA+B;AAC/B,qCAA2C;AAC3C,gCAIO;AACP,iCAA+B;AAC/B,sBAKO;AASA,SAAS,aAOd,SAOA,UACA,aACoC;AACpC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GAAG;AACzD,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,kBAAc,2CAAe;AACnC,QAAM,yBAAqB,2DAA2B;AACtD,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,mBAAmB,OAAO,oBAAoB,OAAO;AAC1D,EAAC,OAAO,kBAAkB,EAAE,SAAiB;AAAA,IAC5C;AAAA,EACF;AAEA,QAAM,QAAQ,OACX,cAAc,EACd,IAKC,iBAAiB,SAAS;AAE9B,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,CAAC,iBAAiB,SAAS;AAC7B,cAAQ;AAAA,QACN,IAAI,iBAAiB,SAAS;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,eAAe;AAG1C,mBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA;AAEN,4CAAqB,gBAAgB;AACrC,iEAAgC,kBAAkB,oBAAoB,KAAK;AAC3E,4DAA2B,kBAAkB;AAG7C,QAAM,kBAAkB,CAAC,OACtB,cAAc,EACd,IAAI,iBAAiB,SAAS;AAEjC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,SAAS,SAAS,oBAAoB,gBAAgB;AAE5D,QAAM,kBAAkB,CAAC,eAAe;AACxC,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBAAkB;AACjB,cAAM,cAAc,kBAChB,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC,IAC1D;AAIJ,iBAAS,aAAa;AAEtB,eAAO;AAAA,MACT;AAAA,MACA,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,gBAAgB;AAAA,EACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;AAG/B,UAAI,+BAAc,kBAAkB,MAAM,GAAG;AAC3C,cAAM,iCAAgB,kBAAkB,UAAU,kBAAkB;AAAA,EACtE;AAGA,UACE,uCAAY;AAAA,IACV;AAAA,IACA;AAAA,IACA,cAAc,iBAAiB;AAAA,IAC/B;AAAA,IACA,UAAU,iBAAiB;AAAA,EAC7B,CAAC,GACD;AACA,UAAM,OAAO;AAAA,EACf;AAEA;AAAC,EAAC,OAAO,kBAAkB,EAAE,SAAiB;AAAA,IAC5C;AAAA,IACA;AAAA,EACF;AAEA,MACE,iBAAiB,iCACjB,CAAC,qCAAmB,SAAS,SAC7B,2BAAU,QAAQ,WAAW,GAC7B;AACA,UAAM,UAAU;AAAA;AAAA,UAEZ,iCAAgB,kBAAkB,UAAU,kBAAkB;AAAA;AAAA;AAAA,MAE9D,OAAO;AAAA;AAEX,aAAS,MAAM,sBAAI,EAAE,QAAQ,MAAM;AAEjC,eAAS,aAAa;AAAA,IACxB,CAAC;AAAA,EACH;AAGA,SAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN;","names":[]}
		{"version":3,"file":"useBaseQuery.cjs","names":["useIsRestoring","useQueryErrorResetBoundary","useQueryClient","React","notifyManager","noop","shouldSuspend","fetchOptimistic","getHasError"],"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;;;;;;;;;;AAyBA,SAAgB,aAOd,SAOA,UACA,aACoC;CACpC,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GACtD,MAAM,IAAI,MACR,gSACF;CAAA;CAIJ,MAAM,cAAcA,4BAAAA,eAAe;CACnC,MAAM,qBAAqBC,gCAAAA,2BAA2B;CACtD,MAAM,SAASC,4BAAAA,eAAe,WAAW;CACzC,MAAM,mBAAmB,OAAO,oBAAoB,OAAO;CAE3D,MAAM,QAAQ,OACX,cAAc,CAAC,CACf,IAKC,iBAAiB,SAAS;CAE9B,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,CAAC,iBAAiB,SACpB,QAAQ,MACN,IAAI,iBAAiB,UAAU,mPACjC;CAAA;CAIJ,MAAM,aAAa,QAAQ,eAAe;CAG1C,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;CAEN,iBAAA,qBAAqB,gBAAgB;CACrC,2BAAA,gCAAgC,kBAAkB,oBAAoB,KAAK;CAC3E,2BAAA,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAYC,MAAM,eAErB,IAAI,SACF,QACA,gBACF,CACJ;CAGA,MAAM,SAAS,SAAS,oBAAoB,gBAAgB;CAE5D,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJA,MAAM,aACH,kBAAkB;EACjB,MAAM,cAAc,kBAChB,SAAS,UAAUC,qBAAAA,cAAc,WAAW,aAAa,CAAC,IAC1DC,qBAAAA;EAIJ,SAAS,aAAa;EAEtB,OAAO;CACT,GACA,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,gBAAgB;CACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;CAG/B,IAAIC,iBAAAA,cAAc,kBAAkB,MAAM,GACxC,MAAMC,iBAAAA,gBAAgB,kBAAkB,UAAU,kBAAkB;CAItE,IACEC,2BAAAA,YAAY;EACV;EACA;EACA,cAAc,iBAAiB;EAC/B;EACA,UAAU,iBAAiB;CAC7B,CAAC,GAED,MAAM,OAAO;CAIf,OAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN"}

+7

-1

build/modern/useBaseQuery.d.cts

		@@ -1,1 +0,7 @@
		export { useBaseQuery } from './_tsup-dts-rollup.cjs';
		import { UseBaseQueryOptions } from "./types.cjs";
		import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/useBaseQuery.d.ts
		declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
		//#endregion
		export { useBaseQuery };
		//# sourceMappingURL=useBaseQuery.d.cts.map

+7

-1

build/modern/useBaseQuery.d.ts

		@@ -1,1 +0,7 @@
		export { useBaseQuery } from './_tsup-dts-rollup.js';
		import { UseBaseQueryOptions } from "./types.js";
		import { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-core";
		//#region src/useBaseQuery.d.ts
		declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;
		//#endregion
		export { useBaseQuery };
		//# sourceMappingURL=useBaseQuery.d.ts.map

+45

-100

build/modern/useBaseQuery.js

		"use client";

		// src/useBaseQuery.ts
		import * as React from "react";
		import { environmentManager, noop, notifyManager } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		import { useIsRestoring } from "./IsRestoringProvider.js";
		import { useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		} from "./errorBoundaryUtils.js";
		import { useIsRestoring } from "./IsRestoringProvider.js";
		import {
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend,
		willFetch
		} from "./suspense.js";
		import { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary } from "./errorBoundaryUtils.js";
		import { ensureSuspenseTimers, fetchOptimistic, shouldSuspend } from "./suspense.js";
		import * as React from "react";
		import { noop, notifyManager } from "@tanstack/query-core";
		//#region src/useBaseQuery.ts
		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`
		);
		}
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		ensureSuspenseTimers(defaultedOptions);
		ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
		useClearResetErrorBoundary(errorResetBoundary);
		const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
		const [observer] = React.useState(
		() => new Observer(
		client,
		defaultedOptions
		)
		);
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
		observer.updateResult();
		return unsubscribe;
		},
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		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)) {
		const promise = isNewCacheEntry ? (
		// Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
		fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
		) : (
		// subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
		query?.promise
		);
		promise?.catch(noop).finally(() => {
		observer.updateResult();
		});
		}
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		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);
		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`);
		}
		const subscribed = options.subscribed !== false;
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		ensureSuspenseTimers(defaultedOptions);
		ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
		useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = React.useState(() => new Observer(client, defaultedOptions));
		const result = observer.getOptimisticResult(defaultedOptions);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(React.useCallback((onStoreChange) => {
		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
		observer.updateResult();
		return unsubscribe;
		}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		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;
		return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
		}
		export {
		useBaseQuery
		};
		//#endregion
		export { useBaseQuery };

		//# sourceMappingURL=useBaseQuery.js.map

+1

-1

build/modern/useBaseQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { environmentManager, noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n willFetch,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n ;(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(\n defaultedOptions,\n )\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n // this needs to be invoked before creating the Observer because that can create a cache entry\n const isNewCacheEntry = !client\n .getQueryCache()\n .get(defaultedOptions.queryHash)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n ;(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(\n defaultedOptions,\n result,\n )\n\n if (\n defaultedOptions.experimental_prefetchInRender &&\n !environmentManager.isServer() &&\n willFetch(result, isRestoring)\n ) {\n const promise = isNewCacheEntry\n ? // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted\n fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n : // subscribe to the \"cache promise\" so that we can finalize the currentThenable once data comes in\n query?.promise\n\n promise?.catch(noop).finally(() => {\n // `.updateResult()` will trigger `.#currentThenable` to finalize\n observer.updateResult()\n })\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,SAAS,oBAAoB,MAAM,qBAAqB;AACxD,SAAS,sBAAsB;AAC/B,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAC/B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AASA,SAAS,aAOd,SAOA,UACA,aACoC;AACpC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GAAG;AACzD,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,cAAc,eAAe;AACnC,QAAM,qBAAqB,2BAA2B;AACtD,QAAM,SAAS,eAAe,WAAW;AACzC,QAAM,mBAAmB,OAAO,oBAAoB,OAAO;AAC1D,EAAC,OAAO,kBAAkB,EAAE,SAAiB;AAAA,IAC5C;AAAA,EACF;AAEA,QAAM,QAAQ,OACX,cAAc,EACd,IAKC,iBAAiB,SAAS;AAE9B,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,CAAC,iBAAiB,SAAS;AAC7B,cAAQ;AAAA,QACN,IAAI,iBAAiB,SAAS;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,eAAe;AAG1C,mBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA;AAEN,uBAAqB,gBAAgB;AACrC,kCAAgC,kBAAkB,oBAAoB,KAAK;AAC3E,6BAA2B,kBAAkB;AAG7C,QAAM,kBAAkB,CAAC,OACtB,cAAc,EACd,IAAI,iBAAiB,SAAS;AAEjC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,SAAS,SAAS,oBAAoB,gBAAgB;AAE5D,QAAM,kBAAkB,CAAC,eAAe;AACxC,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBAAkB;AACjB,cAAM,cAAc,kBAChB,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D;AAIJ,iBAAS,aAAa;AAEtB,eAAO;AAAA,MACT;AAAA,MACA,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,gBAAgB;AAAA,EACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;AAG/B,MAAI,cAAc,kBAAkB,MAAM,GAAG;AAC3C,UAAM,gBAAgB,kBAAkB,UAAU,kBAAkB;AAAA,EACtE;AAGA,MACE,YAAY;AAAA,IACV;AAAA,IACA;AAAA,IACA,cAAc,iBAAiB;AAAA,IAC/B;AAAA,IACA,UAAU,iBAAiB;AAAA,EAC7B,CAAC,GACD;AACA,UAAM,OAAO;AAAA,EACf;AAEA;AAAC,EAAC,OAAO,kBAAkB,EAAE,SAAiB;AAAA,IAC5C;AAAA,IACA;AAAA,EACF;AAEA,MACE,iBAAiB,iCACjB,CAAC,mBAAmB,SAAS,KAC7B,UAAU,QAAQ,WAAW,GAC7B;AACA,UAAM,UAAU;AAAA;AAAA,MAEZ,gBAAgB,kBAAkB,UAAU,kBAAkB;AAAA;AAAA;AAAA,MAE9D,OAAO;AAAA;AAEX,aAAS,MAAM,IAAI,EAAE,QAAQ,MAAM;AAEjC,eAAS,aAAa;AAAA,IACxB,CAAC;AAAA,EACH;AAGA,SAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN;","names":[]}
		{"version":3,"file":"useBaseQuery.js","names":[],"sources":["../../src/useBaseQuery.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' \|\| Array.isArray(options)) {\n throw new Error(\n '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',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${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`,\n )\n }\n }\n\n const subscribed = options.subscribed !== false\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n"],"mappings":";;;;;;;;;AAyBA,SAAgB,aAOd,SAOA,UACA,aACoC;CACpC,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,GACtD,MAAM,IAAI,MACR,gSACF;CAAA;CAIJ,MAAM,cAAc,eAAe;CACnC,MAAM,qBAAqB,2BAA2B;CACtD,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,mBAAmB,OAAO,oBAAoB,OAAO;CAE3D,MAAM,QAAQ,OACX,cAAc,CAAC,CACf,IAKC,iBAAiB,SAAS;CAE9B,IAAI,QAAQ,IAAI,aAAa,cACvB;MAAA,CAAC,iBAAiB,SACpB,QAAQ,MACN,IAAI,iBAAiB,UAAU,mPACjC;CAAA;CAIJ,MAAM,aAAa,QAAQ,eAAe;CAG1C,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;CAEN,qBAAqB,gBAAgB;CACrC,gCAAgC,kBAAkB,oBAAoB,KAAK;CAC3E,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAY,MAAM,eAErB,IAAI,SACF,QACA,gBACF,CACJ;CAGA,MAAM,SAAS,SAAS,oBAAoB,gBAAgB;CAE5D,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJ,MAAM,aACH,kBAAkB;EACjB,MAAM,cAAc,kBAChB,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D;EAIJ,SAAS,aAAa;EAEtB,OAAO;CACT,GACA,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,gBAAgB;CACtC,GAAG,CAAC,kBAAkB,QAAQ,CAAC;CAG/B,IAAI,cAAc,kBAAkB,MAAM,GACxC,MAAM,gBAAgB,kBAAkB,UAAU,kBAAkB;CAItE,IACE,YAAY;EACV;EACA;EACA,cAAc,iBAAiB;EAC/B;EACA,UAAU,iBAAiB;CAC7B,CAAC,GAED,MAAM,OAAO;CAIf,OAAO,CAAC,iBAAiB,sBACrB,SAAS,YAAY,MAAM,IAC3B;AACN"}

+8

-36

build/modern/useInfiniteQuery.cjs

		@@ -1,40 +0,12 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useInfiniteQuery.ts
		var useInfiniteQuery_exports = {};
		__export(useInfiniteQuery_exports, {
		useInfiniteQuery: () => useInfiniteQuery
		});
		module.exports = __toCommonJS(useInfiniteQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useInfiniteQuery.ts
		function useInfiniteQuery(options, queryClient) {
		return (0, import_useBaseQuery.useBaseQuery)(
		options,
		import_query_core.InfiniteQueryObserver,
		queryClient
		);
		return require_useBaseQuery.useBaseQuery(options, _tanstack_query_core.InfiniteQueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useInfiniteQuery
		});
		//#endregion
		exports.useInfiniteQuery = useInfiniteQuery;

		//# sourceMappingURL=useInfiniteQuery.cjs.map

+1

-1

build/modern/useInfiniteQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAAsC;AACtC,0BAA6B;AAqEtB,SAAS,iBACd,SACA,aACA;AACA,aAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useInfiniteQuery.cjs","names":["useBaseQuery","InfiniteQueryObserver"],"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;;;AAuEA,SAAgB,iBACd,SACA,aACA;CACA,OAAOA,qBAAAA,aACL,SACAC,qBAAAA,uBACA,WACF;AACF"}

+10

-1

build/modern/useInfiniteQuery.d.cts

		@@ -1,1 +0,10 @@
		export { useInfiniteQuery_alias_1 as useInfiniteQuery } from './_tsup-dts-rollup.cjs';
		import { DefinedUseInfiniteQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult } from "./types.cjs";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from "./infiniteQueryOptions.cjs";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useInfiniteQuery.d.ts
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useInfiniteQuery };
		//# sourceMappingURL=useInfiniteQuery.d.cts.map

+10

-1

build/modern/useInfiniteQuery.d.ts

		@@ -1,1 +0,10 @@
		export { useInfiniteQuery_alias_1 as useInfiniteQuery } from './_tsup-dts-rollup.js';
		import { DefinedUseInfiniteQueryResult, UseInfiniteQueryOptions, UseInfiniteQueryResult } from "./types.js";
		import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions } from "./infiniteQueryOptions.js";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useInfiniteQuery.d.ts
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useInfiniteQuery };
		//# sourceMappingURL=useInfiniteQuery.d.ts.map

+6

-11

build/modern/useInfiniteQuery.js

		"use client";

		// src/useInfiniteQuery.ts
		import { useBaseQuery } from "./useBaseQuery.js";
		import { InfiniteQueryObserver } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		//#region src/useInfiniteQuery.ts
		function useInfiniteQuery(options, queryClient) {
		return useBaseQuery(
		options,
		InfiniteQueryObserver,
		queryClient
		);
		return useBaseQuery(options, InfiniteQueryObserver, queryClient);
		}
		export {
		useInfiniteQuery
		};
		//#endregion
		export { useInfiniteQuery };

		//# sourceMappingURL=useInfiniteQuery.js.map

+1

-1

build/modern/useInfiniteQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;AACA,SAAS,6BAA6B;AACtC,SAAS,oBAAoB;AAqEtB,SAAS,iBACd,SACA,aACA;AACA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useInfiniteQuery.js","names":[],"sources":["../../src/useInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult<TData, TError>\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"],"mappings":";;;;AAuEA,SAAgB,iBACd,SACA,aACA;CACA,OAAO,aACL,SACA,uBACA,WACF;AACF"}

+13

-52

build/modern/useIsFetching.cjs

		@@ -1,56 +0,17 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useIsFetching.ts
		var useIsFetching_exports = {};
		__export(useIsFetching_exports, {
		useIsFetching: () => useIsFetching
		});
		module.exports = __toCommonJS(useIsFetching_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useIsFetching.ts
		function useIsFetching(filters, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const queryCache = client.getQueryCache();
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => queryCache.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)),
		[queryCache]
		),
		() => client.isFetching(filters),
		() => client.isFetching(filters)
		);
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const queryCache = client.getQueryCache();
		return react.useSyncExternalStore(react.useCallback((onStoreChange) => queryCache.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useIsFetching
		});
		//#endregion
		exports.useIsFetching = useIsFetching;

		//# sourceMappingURL=useIsFetching.cjs.map

+1

-1

build/modern/useIsFetching.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AACvB,wBAA8B;AAE9B,iCAA+B;AAGxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,aAAa,OAAO,cAAc;AAExC,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,WAAW,UAAU,gCAAc,WAAW,aAAa,CAAC;AAAA,MAC9D,CAAC,UAAU;AAAA,IACb;AAAA,IACA,MAAM,OAAO,WAAW,OAAO;AAAA,IAC/B,MAAM,OAAO,WAAW,OAAO;AAAA,EACjC;AACF;","names":[]}
		{"version":3,"file":"useIsFetching.cjs","names":["useQueryClient","React","notifyManager"],"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,MAAM,aAAa,OAAO,cAAc;CAExC,OAAOC,MAAM,qBACXA,MAAM,aACH,kBACC,WAAW,UAAUC,qBAAAA,cAAc,WAAW,aAAa,CAAC,GAC9D,CAAC,UAAU,CACb,SACM,OAAO,WAAW,OAAO,SACzB,OAAO,WAAW,OAAO,CACjC;AACF"}

+6

-1

build/modern/useIsFetching.d.cts

		@@ -1,1 +0,6 @@
		export { useIsFetching_alias_1 as useIsFetching } from './_tsup-dts-rollup.cjs';
		import { QueryClient, QueryFilters } from "@tanstack/query-core";
		//#region src/useIsFetching.d.ts
		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		//#endregion
		export { useIsFetching };
		//# sourceMappingURL=useIsFetching.d.cts.map

+6

-1

build/modern/useIsFetching.d.ts

		@@ -1,1 +0,6 @@
		export { useIsFetching_alias_1 as useIsFetching } from './_tsup-dts-rollup.js';
		import { QueryClient, QueryFilters } from "@tanstack/query-core";
		//#region src/useIsFetching.d.ts
		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		//#endregion
		export { useIsFetching };
		//# sourceMappingURL=useIsFetching.d.ts.map

+8

-16

build/modern/useIsFetching.js

		"use client";

		// src/useIsFetching.ts
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import { notifyManager } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		//#region src/useIsFetching.ts
		function useIsFetching(filters, queryClient) {
		const client = useQueryClient(queryClient);
		const queryCache = client.getQueryCache();
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),
		[queryCache]
		),
		() => client.isFetching(filters),
		() => client.isFetching(filters)
		);
		const client = useQueryClient(queryClient);
		const queryCache = client.getQueryCache();
		return React.useSyncExternalStore(React.useCallback((onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
		}
		export {
		useIsFetching
		};
		//#endregion
		export { useIsFetching };

		//# sourceMappingURL=useIsFetching.js.map

+1

-1

build/modern/useIsFetching.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AACvB,SAAS,qBAAqB;AAE9B,SAAS,sBAAsB;AAGxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,SAAS,eAAe,WAAW;AACzC,QAAM,aAAa,OAAO,cAAc;AAExC,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,WAAW,UAAU,cAAc,WAAW,aAAa,CAAC;AAAA,MAC9D,CAAC,UAAU;AAAA,IACb;AAAA,IACA,MAAM,OAAO,WAAW,OAAO;AAAA,IAC/B,MAAM,OAAO,WAAW,OAAO;AAAA,EACjC;AACF;","names":[]}
		{"version":3,"file":"useIsFetching.js","names":[],"sources":["../../src/useIsFetching.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n"],"mappings":";;;;;AAOA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,aAAa,OAAO,cAAc;CAExC,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,WAAW,UAAU,cAAc,WAAW,aAAa,CAAC,GAC9D,CAAC,UAAU,CACb,SACM,OAAO,WAAW,OAAO,SACzB,OAAO,WAAW,OAAO,CACjC;AACF"}

+25

-70

build/modern/useMutation.cjs

		@@ -1,74 +0,29 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useMutation.ts
		var useMutation_exports = {};
		__export(useMutation_exports, {
		useMutation: () => useMutation
		});
		module.exports = __toCommonJS(useMutation_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useMutation.ts
		function useMutation(options, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const [observer] = React.useState(
		() => new import_query_core.MutationObserver(
		client,
		options
		)
		);
		React.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)),
		[observer]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		const mutate = React.useCallback(
		(variables, mutateOptions) => {
		observer.mutate(variables, mutateOptions).catch(import_query_core.noop);
		},
		[observer]
		);
		if (result.error && (0, import_query_core.shouldThrowError)(observer.options.throwOnError, [result.error])) {
		throw result.error;
		}
		return { ...result, mutate, mutateAsync: result.mutate };
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const [observer] = react.useState(() => new _tanstack_query_core.MutationObserver(client, options));
		react.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = react.useSyncExternalStore(react.useCallback((onStoreChange) => observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		const mutate = react.useCallback((...args) => {
		observer.mutate(args[0], args[1]).catch(_tanstack_query_core.noop);
		}, [observer]);
		if (result.error && (0, _tanstack_query_core.shouldThrowError)(observer.options.throwOnError, [result.error])) throw result.error;
		return {
		...result,
		mutate,
		mutateAsync: result.mutate
		};
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useMutation
		});
		//#endregion
		exports.useMutation = useMutation;

		//# sourceMappingURL=useMutation.cjs.map

+1

-1

build/modern/useMutation.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (variables, mutateOptions) => {\n observer.mutate(variables, mutateOptions).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AACvB,wBAKO;AACP,iCAA+B;AAUxB,SAAS,YAMd,SACA,aAC+D;AAC/D,QAAM,aAAS,2CAAe,WAAW;AAEzC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,OAAO;AAAA,EAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;AAEtB,QAAM,SAAe;AAAA,IACb;AAAA,MACJ,CAAC,kBACC,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC;AAAA,MAC5D,CAAC,QAAQ;AAAA,IACX;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,QAAM,SAAe;AAAA,IAGnB,CAAC,WAAW,kBAAkB;AAC5B,eAAS,OAAO,WAAW,aAAa,EAAE,MAAM,sBAAI;AAAA,IACtD;AAAA,IACA,CAAC,QAAQ;AAAA,EACX;AAEA,MACE,OAAO,aACP,oCAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAC9D;AACA,UAAM,OAAO;AAAA,EACf;AAEA,SAAO,EAAE,GAAG,QAAQ,QAAQ,aAAa,OAAO,OAAO;AACzD;","names":[]}
		{"version":3,"file":"useMutation.cjs","names":["useQueryClient","React","MutationObserver","notifyManager","noop","shouldThrowError"],"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (\n ...args: Parameters<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n ) => {\n observer.mutate(args[0] as TVariables, args[1]).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;;;;;;AAkBA,SAAgB,YAMd,SACA,aAC+D;CAC/D,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,MAAM,CAAC,YAAYC,MAAM,eAErB,IAAIC,qBAAAA,iBACF,QACA,OACF,CACJ;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,OAAO;CAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;CAEtB,MAAM,SAASD,MAAM,qBACnBA,MAAM,aACH,kBACC,SAAS,UAAUE,qBAAAA,cAAc,WAAW,aAAa,CAAC,GAC5D,CAAC,QAAQ,CACX,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,SAASF,MAAM,aAIjB,GAAG,SAGA;EACH,SAAS,OAAO,KAAK,IAAkB,KAAK,EAAE,CAAC,CAAC,MAAMG,qBAAAA,IAAI;CAC5D,GACA,CAAC,QAAQ,CACX;CAEA,IACE,OAAO,UAAA,GACPC,qBAAAA,iBAAAA,CAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAE9D,MAAM,OAAO;CAGf,OAAO;EAAE,GAAG;EAAQ;EAAQ,aAAa,OAAO;CAAO;AACzD"}

+7

-1

build/modern/useMutation.d.cts

		@@ -1,1 +0,7 @@
		export { useMutation_alias_1 as useMutation } from './_tsup-dts-rollup.cjs';
		import { UseMutationOptions, UseMutationResult } from "./types.cjs";
		import { DefaultError, QueryClient } from "@tanstack/query-core";
		//#region src/useMutation.d.ts
		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { useMutation };
		//# sourceMappingURL=useMutation.d.cts.map

+7

-1

build/modern/useMutation.d.ts

		@@ -1,1 +0,7 @@
		export { useMutation_alias_1 as useMutation } from './_tsup-dts-rollup.js';
		import { UseMutationOptions, UseMutationResult } from "./types.js";
		import { DefaultError, QueryClient } from "@tanstack/query-core";
		//#region src/useMutation.d.ts
		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		//#endregion
		export { useMutation };
		//# sourceMappingURL=useMutation.d.ts.map

+21

-40

build/modern/useMutation.js

		"use client";

		// src/useMutation.ts
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import {
		MutationObserver,
		noop,
		notifyManager,
		shouldThrowError
		} from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		import { MutationObserver, noop, notifyManager, shouldThrowError } from "@tanstack/query-core";
		//#region src/useMutation.ts
		function useMutation(options, queryClient) {
		const client = useQueryClient(queryClient);
		const [observer] = React.useState(
		() => new MutationObserver(
		client,
		options
		)
		);
		React.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
		[observer]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		const mutate = 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 };
		const client = useQueryClient(queryClient);
		const [observer] = React.useState(() => new MutationObserver(client, options));
		React.useEffect(() => {
		observer.setOptions(options);
		}, [observer, options]);
		const result = React.useSyncExternalStore(React.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		const mutate = React.useCallback((...args) => {
		observer.mutate(args[0], args[1]).catch(noop);
		}, [observer]);
		if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
		return {
		...result,
		mutate,
		mutateAsync: result.mutate
		};
		}
		export {
		useMutation
		};
		//#endregion
		export { useMutation };

		//# sourceMappingURL=useMutation.js.map

+1

-1

build/modern/useMutation.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (variables, mutateOptions) => {\n observer.mutate(variables, mutateOptions).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AACvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAUxB,SAAS,YAMd,SACA,aAC+D;AAC/D,QAAM,SAAS,eAAe,WAAW;AAEzC,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS,WAAW,OAAO;AAAA,EAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;AAEtB,QAAM,SAAe;AAAA,IACb;AAAA,MACJ,CAAC,kBACC,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC;AAAA,MAC5D,CAAC,QAAQ;AAAA,IACX;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,QAAM,SAAe;AAAA,IAGnB,CAAC,WAAW,kBAAkB;AAC5B,eAAS,OAAO,WAAW,aAAa,EAAE,MAAM,IAAI;AAAA,IACtD;AAAA,IACA,CAAC,QAAQ;AAAA,EACX;AAEA,MACE,OAAO,SACP,iBAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAC9D;AACA,UAAM,OAAO;AAAA,EACf;AAEA,SAAO,EAAE,GAAG,QAAQ,QAAQ,aAAa,OAAO,OAAO;AACzD;","names":[]}
		{"version":3,"file":"useMutation.js","names":[],"sources":["../../src/useMutation.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,\n queryClient?: QueryClient,\n): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver<TData, TError, TVariables, TOnMutateResult>(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >(\n (\n ...args: Parameters<\n UseMutateFunction<TData, TError, TVariables, TOnMutateResult>\n >\n ) => {\n observer.mutate(args[0] as TVariables, args[1]).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n"],"mappings":";;;;;AAkBA,SAAgB,YAMd,SACA,aAC+D;CAC/D,MAAM,SAAS,eAAe,WAAW;CAEzC,MAAM,CAAC,YAAY,MAAM,eAErB,IAAI,iBACF,QACA,OACF,CACJ;CAEA,MAAM,gBAAgB;EACpB,SAAS,WAAW,OAAO;CAC7B,GAAG,CAAC,UAAU,OAAO,CAAC;CAEtB,MAAM,SAAS,MAAM,qBACnB,MAAM,aACH,kBACC,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,GAC5D,CAAC,QAAQ,CACX,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,SAAS,MAAM,aAIjB,GAAG,SAGA;EACH,SAAS,OAAO,KAAK,IAAkB,KAAK,EAAE,CAAC,CAAC,MAAM,IAAI;CAC5D,GACA,CAAC,QAAQ,CACX;CAEA,IACE,OAAO,SACP,iBAAiB,SAAS,QAAQ,cAAc,CAAC,OAAO,KAAK,CAAC,GAE9D,MAAM,OAAO;CAGf,OAAO;EAAE,GAAG;EAAQ;EAAQ,aAAa,OAAO;CAAO;AACzD"}

+31

-78

build/modern/useMutationState.cjs

		@@ -1,86 +0,39 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useMutationState.ts
		var useMutationState_exports = {};
		__export(useMutationState_exports, {
		useIsMutating: () => useIsMutating,
		useMutationState: () => useMutationState
		});
		module.exports = __toCommonJS(useMutationState_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useMutationState.ts
		function useIsMutating(filters, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		return useMutationState(
		{ filters: { ...filters, status: "pending" } },
		client
		).length;
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		return useMutationState({ filters: {
		...filters,
		status: "pending"
		} }, client).length;
		}
		function getResult(mutationCache, options) {
		return mutationCache.findAll(options.filters).map(
		(mutation) => options.select ? options.select(mutation) : mutation.state
		);
		return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
		}
		function useMutationState(options = {}, queryClient) {
		const mutationCache = (0, import_QueryClientProvider.useQueryClient)(queryClient).getMutationCache();
		const optionsRef = React.useRef(options);
		const result = React.useRef(null);
		if (result.current === null) {
		result.current = getResult(mutationCache, options);
		}
		React.useEffect(() => {
		optionsRef.current = options;
		});
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = (0, import_query_core.replaceEqualDeep)(
		result.current,
		getResult(mutationCache, optionsRef.current)
		);
		if (result.current !== nextResult) {
		result.current = nextResult;
		import_query_core.notifyManager.schedule(onStoreChange);
		}
		}),
		[mutationCache]
		),
		() => result.current,
		() => result.current
		);
		const mutationCache = require_QueryClientProvider.useQueryClient(queryClient).getMutationCache();
		const optionsRef = react.useRef(options);
		const result = react.useRef(null);
		if (result.current === null) result.current = getResult(mutationCache, options);
		react.useEffect(() => {
		optionsRef.current = options;
		});
		return react.useSyncExternalStore(react.useCallback((onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = (0, _tanstack_query_core.replaceEqualDeep)(result.current, getResult(mutationCache, optionsRef.current));
		if (result.current !== nextResult) {
		result.current = nextResult;
		_tanstack_query_core.notifyManager.schedule(onStoreChange);
		}
		}), [mutationCache]), () => result.current, () => result.current);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useIsMutating,
		useMutationState
		});
		//#endregion
		exports.useIsMutating = useIsMutating;
		exports.useMutationState = useMutationState;

		//# sourceMappingURL=useMutationState.cjs.map

+1

-1

build/modern/useMutationState.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationStateOptions<TResult = MutationState> = {\n filters?: MutationFilters\n select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult<TResult = MutationState>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select ? options.select(mutation) : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<TResult = MutationState>(\n options: MutationStateOptions<TResult> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAAgD;AAChD,iCAA+B;AASxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,aAAS,2CAAe,WAAW;AACzC,SAAO;AAAA,IACL,EAAE,SAAS,EAAE,GAAG,SAAS,QAAQ,UAAU,EAAE;AAAA,IAC7C;AAAA,EACF,EAAE;AACJ;AAOA,SAAS,UACP,eACA,SACgB;AAChB,SAAO,cACJ,QAAQ,QAAQ,OAAO,EACvB;AAAA,IACC,CAAC,aACE,QAAQ,SAAS,QAAQ,OAAO,QAAQ,IAAI,SAAS;AAAA,EAC1D;AACJ;AAEO,SAAS,iBACd,UAAyC,CAAC,GAC1C,aACgB;AAChB,QAAM,oBAAgB,2CAAe,WAAW,EAAE,iBAAiB;AACnE,QAAM,aAAmB,aAAO,OAAO;AACvC,QAAM,SAAe,aAAuB,IAAI;AAChD,MAAI,OAAO,YAAY,MAAM;AAC3B,WAAO,UAAU,UAAU,eAAe,OAAO;AAAA,EACnD;AAEA,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAED,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,cAAc,UAAU,MAAM;AAC5B,cAAM,iBAAa;AAAA,UACjB,OAAO;AAAA,UACP,UAAU,eAAe,WAAW,OAAO;AAAA,QAC7C;AACA,YAAI,OAAO,YAAY,YAAY;AACjC,iBAAO,UAAU;AACjB,0CAAc,SAAS,aAAa;AAAA,QACtC;AAAA,MACF,CAAC;AAAA,MACH,CAAC,aAAa;AAAA,IAChB;AAAA,IACA,MAAM,OAAO;AAAA,IACb,MAAM,OAAO;AAAA,EACf;AACF;","names":[]}
		{"version":3,"file":"useMutationState.cjs","names":["useQueryClient","React","replaceEqualDeep"],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;;;;AAaA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;AAEA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgBA,4BAAAA,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAaC,MAAM,OAAO,OAAO;CACvC,MAAM,SAASA,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAOA,MAAM,qBACXA,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,cAAA,GAAaC,qBAAAA,iBAAAA,CACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,qBAAA,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}

+12

-2

build/modern/useMutationState.d.cts

		@@ -1,2 +0,12 @@
		export { useIsMutating_alias_1 as useIsMutating } from './_tsup-dts-rollup.cjs';
		export { useMutationState_alias_1 as useMutationState } from './_tsup-dts-rollup.cjs';
		import { Mutation, MutationFilters, MutationState, QueryClient } from "@tanstack/query-core";
		//#region src/useMutationState.d.ts
		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		type MutationTypeFromResult<TResult> = [TResult] extends [MutationState<infer TData, infer TError, infer TVariables, infer TOnMutateResult>] ? Mutation<TData, TError, TVariables, TOnMutateResult> : Mutation;
		type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>> = {
		filters?: MutationFilters;
		select?: (mutation: TMutation) => TResult;
		};
		declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
		//#endregion
		export { useIsMutating, useMutationState };
		//# sourceMappingURL=useMutationState.d.cts.map

+12

-2

build/modern/useMutationState.d.ts

		@@ -1,2 +0,12 @@
		export { useIsMutating_alias_1 as useIsMutating } from './_tsup-dts-rollup.js';
		export { useMutationState_alias_1 as useMutationState } from './_tsup-dts-rollup.js';
		import { Mutation, MutationFilters, MutationState, QueryClient } from "@tanstack/query-core";
		//#region src/useMutationState.d.ts
		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		type MutationTypeFromResult<TResult> = [TResult] extends [MutationState<infer TData, infer TError, infer TVariables, infer TOnMutateResult>] ? Mutation<TData, TError, TVariables, TOnMutateResult> : Mutation;
		type MutationStateOptions<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>> = {
		filters?: MutationFilters;
		select?: (mutation: TMutation) => TResult;
		};
		declare function useMutationState<TResult = MutationState, TMutation extends Mutation<any, any, any, any> = MutationTypeFromResult<TResult>>(options?: MutationStateOptions<TResult, TMutation>, queryClient?: QueryClient): Array<TResult>;
		//#endregion
		export { useIsMutating, useMutationState };
		//# sourceMappingURL=useMutationState.d.ts.map

+25

-41

build/modern/useMutationState.js

		"use client";

		// src/useMutationState.ts
		import { useQueryClient } from "./QueryClientProvider.js";
		import * as React from "react";
		import { notifyManager, replaceEqualDeep } from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		//#region src/useMutationState.ts
		function useIsMutating(filters, queryClient) {
		const client = useQueryClient(queryClient);
		return useMutationState(
		{ filters: { ...filters, status: "pending" } },
		client
		).length;
		const client = useQueryClient(queryClient);
		return useMutationState({ filters: {
		...filters,
		status: "pending"
		} }, client).length;
		}
		function getResult(mutationCache, options) {
		return mutationCache.findAll(options.filters).map(
		(mutation) => options.select ? options.select(mutation) : mutation.state
		);
		return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
		}
		function useMutationState(options = {}, queryClient) {
		const mutationCache = useQueryClient(queryClient).getMutationCache();
		const optionsRef = React.useRef(options);
		const result = React.useRef(null);
		if (result.current === null) {
		result.current = getResult(mutationCache, options);
		}
		React.useEffect(() => {
		optionsRef.current = options;
		});
		return React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = replaceEqualDeep(
		result.current,
		getResult(mutationCache, optionsRef.current)
		);
		if (result.current !== nextResult) {
		result.current = nextResult;
		notifyManager.schedule(onStoreChange);
		}
		}),
		[mutationCache]
		),
		() => result.current,
		() => result.current
		);
		const mutationCache = useQueryClient(queryClient).getMutationCache();
		const optionsRef = React.useRef(options);
		const result = React.useRef(null);
		if (result.current === null) result.current = getResult(mutationCache, options);
		React.useEffect(() => {
		optionsRef.current = options;
		});
		return React.useSyncExternalStore(React.useCallback((onStoreChange) => mutationCache.subscribe(() => {
		const nextResult = replaceEqualDeep(result.current, getResult(mutationCache, optionsRef.current));
		if (result.current !== nextResult) {
		result.current = nextResult;
		notifyManager.schedule(onStoreChange);
		}
		}), [mutationCache]), () => result.current, () => result.current);
		}
		export {
		useIsMutating,
		useMutationState
		};
		//#endregion
		export { useIsMutating, useMutationState };

		//# sourceMappingURL=useMutationState.js.map

+1

-1

build/modern/useMutationState.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationStateOptions<TResult = MutationState> = {\n filters?: MutationFilters\n select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult<TResult = MutationState>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select ? options.select(mutation) : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<TResult = MutationState>(\n options: MutationStateOptions<TResult> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB,SAAS,eAAe,wBAAwB;AAChD,SAAS,sBAAsB;AASxB,SAAS,cACd,SACA,aACQ;AACR,QAAM,SAAS,eAAe,WAAW;AACzC,SAAO;AAAA,IACL,EAAE,SAAS,EAAE,GAAG,SAAS,QAAQ,UAAU,EAAE;AAAA,IAC7C;AAAA,EACF,EAAE;AACJ;AAOA,SAAS,UACP,eACA,SACgB;AAChB,SAAO,cACJ,QAAQ,QAAQ,OAAO,EACvB;AAAA,IACC,CAAC,aACE,QAAQ,SAAS,QAAQ,OAAO,QAAQ,IAAI,SAAS;AAAA,EAC1D;AACJ;AAEO,SAAS,iBACd,UAAyC,CAAC,GAC1C,aACgB;AAChB,QAAM,gBAAgB,eAAe,WAAW,EAAE,iBAAiB;AACnE,QAAM,aAAmB,aAAO,OAAO;AACvC,QAAM,SAAe,aAAuB,IAAI;AAChD,MAAI,OAAO,YAAY,MAAM;AAC3B,WAAO,UAAU,UAAU,eAAe,OAAO;AAAA,EACnD;AAEA,EAAM,gBAAU,MAAM;AACpB,eAAW,UAAU;AAAA,EACvB,CAAC;AAED,SAAa;AAAA,IACL;AAAA,MACJ,CAAC,kBACC,cAAc,UAAU,MAAM;AAC5B,cAAM,aAAa;AAAA,UACjB,OAAO;AAAA,UACP,UAAU,eAAe,WAAW,OAAO;AAAA,QAC7C;AACA,YAAI,OAAO,YAAY,YAAY;AACjC,iBAAO,UAAU;AACjB,wBAAc,SAAS,aAAa;AAAA,QACtC;AAAA,MACF,CAAC;AAAA,MACH,CAAC,aAAa;AAAA,IAChB;AAAA,IACA,MAAM,OAAO;AAAA,IACb,MAAM,OAAO;AAAA,EACf;AACF;","names":[]}
		{"version":3,"file":"useMutationState.js","names":[],"sources":["../../src/useMutationState.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationTypeFromResult<TResult> = [TResult] extends [\n MutationState<\n infer TData,\n infer TError,\n infer TVariables,\n infer TOnMutateResult\n >,\n]\n ? Mutation<TData, TError, TVariables, TOnMutateResult>\n : Mutation\n\ntype MutationStateOptions<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n> = {\n filters?: MutationFilters\n select?: (mutation: TMutation) => TResult\n}\n\nfunction getResult<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n mutationCache: MutationCache,\n options: MutationStateOptions<TResult, TMutation>,\n): Array<TResult> {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select\n ? options.select(mutation as TMutation)\n : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState<\n TResult = MutationState,\n TMutation extends Mutation<any, any, any, any> =\n MutationTypeFromResult<TResult>,\n>(\n options: MutationStateOptions<TResult, TMutation> = {},\n queryClient?: QueryClient,\n): Array<TResult> {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef<Array<TResult>>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n"],"mappings":";;;;;AAaA,SAAgB,cACd,SACA,aACQ;CACR,MAAM,SAAS,eAAe,WAAW;CACzC,OAAO,iBACL,EAAE,SAAS;EAAE,GAAG;EAAS,QAAQ;CAAU,EAAE,GAC7C,MACF,CAAC,CAAC;AACJ;AAsBA,SAAS,UAKP,eACA,SACgB;CAChB,OAAO,cACJ,QAAQ,QAAQ,OAAO,CAAC,CACxB,KACE,aACE,QAAQ,SACL,QAAQ,OAAO,QAAqB,IACpC,SAAS,KACjB;AACJ;AAEA,SAAgB,iBAKd,UAAoD,CAAC,GACrD,aACgB;CAChB,MAAM,gBAAgB,eAAe,WAAW,CAAC,CAAC,iBAAiB;CACnE,MAAM,aAAa,MAAM,OAAO,OAAO;CACvC,MAAM,SAAS,MAAM,OAAuB,IAAI;CAChD,IAAI,OAAO,YAAY,MACrB,OAAO,UAAU,UAAU,eAAe,OAAO;CAGnD,MAAM,gBAAgB;EACpB,WAAW,UAAU;CACvB,CAAC;CAED,OAAO,MAAM,qBACX,MAAM,aACH,kBACC,cAAc,gBAAgB;EAC5B,MAAM,aAAa,iBACjB,OAAO,SACP,UAAU,eAAe,WAAW,OAAO,CAC7C;EACA,IAAI,OAAO,YAAY,YAAY;GACjC,OAAO,UAAU;GACjB,cAAc,SAAS,aAAa;EACtC;CACF,CAAC,GACH,CAAC,aAAa,CAChB,SACM,OAAO,eACP,OAAO,OACf;AACF"}

+9

-34

build/modern/usePrefetchInfiniteQuery.cjs

		@@ -1,37 +0,12 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/usePrefetchInfiniteQuery.tsx
		var usePrefetchInfiniteQuery_exports = {};
		__export(usePrefetchInfiniteQuery_exports, {
		usePrefetchInfiniteQuery: () => usePrefetchInfiniteQuery
		});
		module.exports = __toCommonJS(usePrefetchInfiniteQuery_exports);
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/usePrefetchInfiniteQuery.tsx
		function usePrefetchInfiniteQuery(options, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchInfiniteQuery(options);
		}
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(_tanstack_query_core.noop);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		usePrefetchInfiniteQuery
		});
		//#endregion
		exports.usePrefetchInfiniteQuery = usePrefetchInfiniteQuery;

		//# sourceMappingURL=usePrefetchInfiniteQuery.cjs.map

+1

-1

build/modern/usePrefetchInfiniteQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type {\n DefaultError,\n FetchInfiniteQueryOptions,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchInfiniteQuery(options)\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA+B;AAQxB,SAAS,yBAOd,SAOA,aACA;AACA,QAAM,aAAS,2CAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,sBAAsB,OAAO;AAAA,EACtC;AACF;","names":[]}
		{"version":3,"file":"usePrefetchInfiniteQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UsePrefetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.infiniteQuery(options).catch(noop)\n }\n}\n"],"mappings":";;;;AAWA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEjD"}

+7

-1

build/modern/usePrefetchInfiniteQuery.d.cts

		@@ -1,1 +0,7 @@
		export { usePrefetchInfiniteQuery_alias_1 as usePrefetchInfiniteQuery } from './_tsup-dts-rollup.cjs';
		import { UsePrefetchInfiniteQueryOptions } from "./types.cjs";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchInfiniteQuery.d.ts
		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchInfiniteQuery };
		//# sourceMappingURL=usePrefetchInfiniteQuery.d.cts.map

+7

-1

build/modern/usePrefetchInfiniteQuery.d.ts

		@@ -1,1 +0,7 @@
		export { usePrefetchInfiniteQuery_alias_1 as usePrefetchInfiniteQuery } from './_tsup-dts-rollup.js';
		import { UsePrefetchInfiniteQueryOptions } from "./types.js";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchInfiniteQuery.d.ts
		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UsePrefetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchInfiniteQuery };
		//# sourceMappingURL=usePrefetchInfiniteQuery.d.ts.map

+7

-8

build/modern/usePrefetchInfiniteQuery.js

		@@ -1,12 +0,11 @@
		// src/usePrefetchInfiniteQuery.tsx
		import { useQueryClient } from "./QueryClientProvider.js";
		import { noop } from "@tanstack/query-core";
		//#region src/usePrefetchInfiniteQuery.tsx
		function usePrefetchInfiniteQuery(options, queryClient) {
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchInfiniteQuery(options);
		}
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(noop);
		}
		export {
		usePrefetchInfiniteQuery
		};
		//#endregion
		export { usePrefetchInfiniteQuery };

		//# sourceMappingURL=usePrefetchInfiniteQuery.js.map

+1

-1

build/modern/usePrefetchInfiniteQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type {\n DefaultError,\n FetchInfiniteQueryOptions,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchInfiniteQuery(options)\n }\n}\n"],"mappings":";AAAA,SAAS,sBAAsB;AAQxB,SAAS,yBAOd,SAOA,aACA;AACA,QAAM,SAAS,eAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,sBAAsB,OAAO;AAAA,EACtC;AACF;","names":[]}
		{"version":3,"file":"usePrefetchInfiniteQuery.js","names":[],"sources":["../../src/usePrefetchInfiniteQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\nimport type { UsePrefetchInfiniteQueryOptions } from './types'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UsePrefetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.infiniteQuery(options).catch(noop)\n }\n}\n"],"mappings":";;;AAWA,SAAgB,yBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,cAAc,OAAO,CAAC,CAAC,MAAM,IAAI;AAEjD"}

+9

-34

build/modern/usePrefetchQuery.cjs

		@@ -1,37 +0,12 @@
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/usePrefetchQuery.tsx
		var usePrefetchQuery_exports = {};
		__export(usePrefetchQuery_exports, {
		usePrefetchQuery: () => usePrefetchQuery
		});
		module.exports = __toCommonJS(usePrefetchQuery_exports);
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/usePrefetchQuery.tsx
		function usePrefetchQuery(options, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchQuery(options);
		}
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.query(options).catch(_tanstack_query_core.noop);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		usePrefetchQuery
		});
		//#endregion
		exports.usePrefetchQuery = usePrefetchQuery;

		//# sourceMappingURL=usePrefetchQuery.cjs.map

+1

-1

build/modern/usePrefetchQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchQuery(options)\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA+B;AAIxB,SAAS,iBAMd,SACA,aACA;AACA,QAAM,aAAS,2CAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,cAAc,OAAO;AAAA,EAC9B;AACF;","names":[]}
		{"version":3,"file":"usePrefetchQuery.cjs","names":["useQueryClient","noop"],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.query(options).catch(noop)\n }\n}\n"],"mappings":";;;;AAMA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAASA,4BAAAA,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAMC,qBAAAA,IAAI;AAEzC"}

+7

-1

build/modern/usePrefetchQuery.d.cts

		@@ -1,1 +0,7 @@
		export { usePrefetchQuery_alias_1 as usePrefetchQuery } from './_tsup-dts-rollup.cjs';
		import { UsePrefetchQueryOptions } from "./types.cjs";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchQuery.d.ts
		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchQuery };
		//# sourceMappingURL=usePrefetchQuery.d.cts.map

+7

-1

build/modern/usePrefetchQuery.d.ts

		@@ -1,1 +0,7 @@
		export { usePrefetchQuery_alias_1 as usePrefetchQuery } from './_tsup-dts-rollup.js';
		import { UsePrefetchQueryOptions } from "./types.js";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/usePrefetchQuery.d.ts
		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, queryClient?: QueryClient): void;
		//#endregion
		export { usePrefetchQuery };
		//# sourceMappingURL=usePrefetchQuery.d.ts.map

+7

-8

build/modern/usePrefetchQuery.js

		@@ -1,12 +0,11 @@
		// src/usePrefetchQuery.tsx
		import { useQueryClient } from "./QueryClientProvider.js";
		import { noop } from "@tanstack/query-core";
		//#region src/usePrefetchQuery.tsx
		function usePrefetchQuery(options, queryClient) {
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) {
		client.prefetchQuery(options);
		}
		const client = useQueryClient(queryClient);
		if (!client.getQueryState(options.queryKey)) client.query(options).catch(noop);
		}
		export {
		usePrefetchQuery
		};
		//#endregion
		export { usePrefetchQuery };

		//# sourceMappingURL=usePrefetchQuery.js.map

+1

-1

build/modern/usePrefetchQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { useQueryClient } from './QueryClientProvider'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchQuery(options)\n }\n}\n"],"mappings":";AAAA,SAAS,sBAAsB;AAIxB,SAAS,iBAMd,SACA,aACA;AACA,QAAM,SAAS,eAAe,WAAW;AAEzC,MAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GAAG;AAC3C,WAAO,cAAc,OAAO;AAAA,EAC9B;AACF;","names":[]}
		{"version":3,"file":"usePrefetchQuery.js","names":[],"sources":["../../src/usePrefetchQuery.tsx"],"sourcesContent":["import { noop } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\n\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n queryClient?: QueryClient,\n): void {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n void client.query(options).catch(noop)\n }\n}\n"],"mappings":";;;AAMA,SAAgB,iBAOd,SAOA,aACM;CACN,MAAM,SAAS,eAAe,WAAW;CAEzC,IAAI,CAAC,OAAO,cAAc,QAAQ,QAAQ,GACxC,OAAY,MAAM,OAAO,CAAC,CAAC,MAAM,IAAI;AAEzC"}

+67

-125

build/modern/useQueries.cjs

		@@ -1,128 +0,70 @@
		"use strict";
		"use client";
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
		// If the importer is in node compatibility mode or this is not an ESM
		// file that has been converted to a CommonJS file using a Babel-
		// compatible transform (i.e. "__esModule" has not been set), then set
		// "default" to the CommonJS "module.exports" for node compatibility.
		isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
		mod
		));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
		const require_QueryClientProvider = require("./QueryClientProvider.cjs");
		const require_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		const require_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		const require_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		const require_suspense = require("./suspense.cjs");
		let react = require("react");
		react = require_rolldown_runtime.__toESM(react, 1);
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useQueries.ts
		function useQueries({ queries, ...options }, queryClient) {
		const client = require_QueryClientProvider.useQueryClient(queryClient);
		const isRestoring = require_IsRestoringProvider.useIsRestoring();
		const errorResetBoundary = require_QueryErrorResetBoundary.useQueryErrorResetBoundary();
		const subscribed = options.subscribed !== false;
		const defaultedQueries = react.useMemo(() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(opts);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		return defaultedOptions;
		}), [
		queries,
		client,
		isRestoring,
		subscribed
		]);
		defaultedQueries.forEach((queryOptions) => {
		require_suspense.ensureSuspenseTimers(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		require_errorBoundaryUtils.ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
		});
		require_errorBoundaryUtils.useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = react.useState(() => new _tanstack_query_core.QueriesObserver(client, defaultedQueries, options));
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
		const shouldSubscribe = !isRestoring && subscribed;
		react.useSyncExternalStore(react.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(_tanstack_query_core.notifyManager.batchCalls(onStoreChange)) : _tanstack_query_core.noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		react.useEffect(() => {
		observer.setQueries(defaultedQueries, options);
		}, [
		defaultedQueries,
		options,
		observer
		]);
		const suspensePromises = optimisticResult.some((result, index) => require_suspense.shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && require_suspense.shouldSuspend(opts, result)) {
		const queryObserver = new _tanstack_query_core.QueryObserver(client, opts);
		return require_suspense.fetchOptimistic(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
		const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
		const query = defaultedQueries[index];
		return query && require_errorBoundaryUtils.getHasError({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		});
		if (firstSingleResultWhichShouldThrow?.error) throw firstSingleResultWhichShouldThrow.error;
		return getCombinedResult(trackResult());
		}
		//#endregion
		exports.useQueries = useQueries;

		// src/useQueries.ts
		var useQueries_exports = {};
		__export(useQueries_exports, {
		useQueries: () => useQueries
		});
		module.exports = __toCommonJS(useQueries_exports);
		var React = __toESM(require("react"), 1);
		var import_query_core = require("@tanstack/query-core");
		var import_QueryClientProvider = require("./QueryClientProvider.cjs");
		var import_IsRestoringProvider = require("./IsRestoringProvider.cjs");
		var import_QueryErrorResetBoundary = require("./QueryErrorResetBoundary.cjs");
		var import_errorBoundaryUtils = require("./errorBoundaryUtils.cjs");
		var import_suspense = require("./suspense.cjs");
		function useQueries({
		queries,
		...options
		}, queryClient) {
		const client = (0, import_QueryClientProvider.useQueryClient)(queryClient);
		const isRestoring = (0, import_IsRestoringProvider.useIsRestoring)();
		const errorResetBoundary = (0, import_QueryErrorResetBoundary.useQueryErrorResetBoundary)();
		const defaultedQueries = React.useMemo(
		() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(
		opts
		);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
		return defaultedOptions;
		}),
		[queries, client, isRestoring]
		);
		defaultedQueries.forEach((queryOptions) => {
		(0, import_suspense.ensureSuspenseTimers)(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		(0, import_errorBoundaryUtils.ensurePreventErrorBoundaryRetry)(queryOptions, errorResetBoundary, query);
		});
		(0, import_errorBoundaryUtils.useClearResetErrorBoundary)(errorResetBoundary);
		const [observer] = React.useState(
		() => new import_query_core.QueriesObserver(
		client,
		defaultedQueries,
		options
		)
		);
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
		defaultedQueries,
		options.combine
		);
		const shouldSubscribe = !isRestoring && options.subscribed !== false;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => shouldSubscribe ? observer.subscribe(import_query_core.notifyManager.batchCalls(onStoreChange)) : import_query_core.noop,
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		React.useEffect(() => {
		observer.setQueries(
		defaultedQueries,
		options
		);
		}, [defaultedQueries, options, observer]);
		const shouldAtLeastOneSuspend = optimisticResult.some(
		(result, index) => (0, import_suspense.shouldSuspend)(defaultedQueries[index], result)
		);
		const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && (0, import_suspense.shouldSuspend)(opts, result)) {
		const queryObserver = new import_query_core.QueryObserver(client, opts);
		return (0, import_suspense.fetchOptimistic)(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) {
		throw Promise.all(suspensePromises);
		}
		const firstSingleResultWhichShouldThrow = optimisticResult.find(
		(result, index) => {
		const query = defaultedQueries[index];
		return query && (0, import_errorBoundaryUtils.getHasError)({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		}
		);
		if (firstSingleResultWhichShouldThrow?.error) {
		throw firstSingleResultWhichShouldThrow.error;
		}
		return getCombinedResult(trackResult());
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useQueries
		});
		//# sourceMappingURL=useQueries.cjs.map

+1

-1

build/modern/useQueries.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n return defaultedOptions\n }),\n [queries, client, isRestoring],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,YAAuB;AAEvB,wBAKO;AACP,iCAA+B;AAC/B,iCAA+B;AAC/B,qCAA2C;AAC3C,gCAIO;AACP,sBAIO;AAyLA,SAAS,WAId;AAAA,EACE;AAAA,EACA,GAAG;AACL,GAOA,aACiB;AACjB,QAAM,aAAS,2CAAe,WAAW;AACzC,QAAM,kBAAc,2CAAe;AACnC,QAAM,yBAAqB,2DAA2B;AAEtD,QAAM,mBAAyB;AAAA,IAC7B,MACE,QAAQ,IAAI,CAAC,SAAS;AACpB,YAAM,mBAAmB,OAAO;AAAA,QAC9B;AAAA,MACF;AAGA,uBAAiB,qBAAqB,cAClC,gBACA;AAEJ,aAAO;AAAA,IACT,CAAC;AAAA,IACH,CAAC,SAAS,QAAQ,WAAW;AAAA,EAC/B;AAEA,mBAAiB,QAAQ,CAAC,iBAAiB;AACzC,8CAAqB,YAAY;AACjC,UAAM,QAAQ,OAAO,cAAc,EAAE,IAAI,aAAa,SAAS;AAC/D,mEAAgC,cAAc,oBAAoB,KAAK;AAAA,EACzE,CAAC;AAED,4DAA2B,kBAAkB;AAE7C,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,CAAC,kBAAkB,mBAAmB,WAAW,IACrD,SAAS;AAAA,IACP;AAAA,IACC,QAAoD;AAAA,EACvD;AAEF,QAAM,kBAAkB,CAAC,eAAe,QAAQ,eAAe;AAC/D,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBACC,kBACI,SAAS,UAAU,gCAAc,WAAW,aAAa,CAAC,IAC1D;AAAA,MACN,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS;AAAA,MACP;AAAA,MACA;AAAA,IACF;AAAA,EACF,GAAG,CAAC,kBAAkB,SAAS,QAAQ,CAAC;AAExC,QAAM,0BAA0B,iBAAiB;AAAA,IAAK,CAAC,QAAQ,cAC7D,+BAAc,iBAAiB,KAAK,GAAG,MAAM;AAAA,EAC/C;AAEA,QAAM,mBAAmB,0BACrB,iBAAiB,QAAQ,CAAC,QAAQ,UAAU;AAC1C,UAAM,OAAO,iBAAiB,KAAK;AAEnC,QAAI,YAAQ,+BAAc,MAAM,MAAM,GAAG;AACvC,YAAM,gBAAgB,IAAI,gCAAc,QAAQ,IAAI;AACpD,iBAAO,iCAAgB,MAAM,eAAe,kBAAkB;AAAA,IAChE;AACA,WAAO,CAAC;AAAA,EACV,CAAC,IACD,CAAC;AAEL,MAAI,iBAAiB,SAAS,GAAG;AAC/B,UAAM,QAAQ,IAAI,gBAAgB;AAAA,EACpC;AACA,QAAM,oCAAoC,iBAAiB;AAAA,IACzD,CAAC,QAAQ,UAAU;AACjB,YAAM,QAAQ,iBAAiB,KAAK;AACpC,aACE,aACA,uCAAY;AAAA,QACV;AAAA,QACA;AAAA,QACA,cAAc,MAAM;AAAA,QACpB,OAAO,OAAO,cAAc,EAAE,IAAI,MAAM,SAAS;AAAA,QACjD,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IAEL;AAAA,EACF;AAEA,MAAI,mCAAmC,OAAO;AAC5C,UAAM,kCAAkC;AAAA,EAC1C;AAEA,SAAO,kBAAkB,YAAY,CAAC;AACxC;","names":[]}
		{"version":3,"file":"useQueries.cjs","names":["useQueryClient","useIsRestoring","useQueryErrorResetBoundary","React","QueriesObserver","notifyManager","noop","shouldSuspend","QueryObserver","fetchOptimistic","getHasError"],"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const subscribed = options.subscribed !== false\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n return defaultedOptions\n }),\n [queries, client, isRestoring, subscribed],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;;;;AA8MA,SAAgB,WAId,EACE,SACA,GAAG,WAQL,aACiB;CACjB,MAAM,SAASA,4BAAAA,eAAe,WAAW;CACzC,MAAM,cAAcC,4BAAAA,eAAe;CACnC,MAAM,qBAAqBC,gCAAAA,2BAA2B;CACtD,MAAM,aAAa,QAAQ,eAAe;CAE1C,MAAM,mBAAmBC,MAAM,cAE3B,QAAQ,KAAK,SAAS;EACpB,MAAM,mBAAmB,OAAO,oBAC9B,IACF;EAGA,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;EAEN,OAAO;CACT,CAAC,GACH;EAAC;EAAS;EAAQ;EAAa;CAAU,CAC3C;CAEA,iBAAiB,SAAS,iBAAiB;EACzC,iBAAA,qBAAqB,YAAY;EACjC,MAAM,QAAQ,OAAO,cAAc,CAAC,CAAC,IAAI,aAAa,SAAS;EAC/D,2BAAA,gCAAgC,cAAc,oBAAoB,KAAK;CACzE,CAAC;CAED,2BAAA,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAYA,MAAM,eAErB,IAAIC,qBAAAA,gBACF,QACA,kBACA,OACF,CACJ;CAGA,MAAM,CAAC,kBAAkB,mBAAmB,eAC1C,SAAS,oBACP,kBACC,QAAoD,OACvD;CAEF,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJD,MAAM,aACH,kBACC,kBACI,SAAS,UAAUE,qBAAAA,cAAc,WAAW,aAAa,CAAC,IAC1DC,qBAAAA,MACN,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WACP,kBACA,OACF;CACF,GAAG;EAAC;EAAkB;EAAS;CAAQ,CAAC;CAMxC,MAAM,mBAJ0B,iBAAiB,MAAM,QAAQ,UAC7DC,iBAAAA,cAAc,iBAAiB,QAAQ,MAAM,CAGA,IAC3C,iBAAiB,SAAS,QAAQ,UAAU;EAC1C,MAAM,OAAO,iBAAiB;EAE9B,IAAI,QAAQA,iBAAAA,cAAc,MAAM,MAAM,GAAG;GACvC,MAAM,gBAAgB,IAAIC,qBAAAA,cAAc,QAAQ,IAAI;GACpD,OAAOC,iBAAAA,gBAAgB,MAAM,eAAe,kBAAkB;EAChE;EACA,OAAO,CAAC;CACV,CAAC,IACD,CAAC;CAEL,IAAI,iBAAiB,SAAS,GAC5B,MAAM,QAAQ,IAAI,gBAAgB;CAEpC,MAAM,oCAAoC,iBAAiB,MACxD,QAAQ,UAAU;EACjB,MAAM,QAAQ,iBAAiB;EAC/B,OACE,SACAC,2BAAAA,YAAY;GACV;GACA;GACA,cAAc,MAAM;GACpB,OAAO,OAAO,cAAc,CAAC,CAAC,IAAI,MAAM,SAAS;GACjD,UAAU,MAAM;EAClB,CAAC;CAEL,CACF;CAEA,IAAI,mCAAmC,OACrC,MAAM,kCAAkC;CAG1C,OAAO,kBAAkB,YAAY,CAAC;AACxC"}

+57

-3

build/modern/useQueries.d.cts

		@@ -1,3 +0,57 @@
		export { useQueries_alias_1 as useQueries } from './_tsup-dts-rollup.cjs';
		export { QueriesOptions_alias_1 as QueriesOptions } from './_tsup-dts-rollup.cjs';
		export { QueriesResults_alias_1 as QueriesResults } from './_tsup-dts-rollup.cjs';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.cjs";
		import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
		//#region src/useQueries.d.ts
		type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
		type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
		type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetUseQueryOptionsForUseQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetUseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseQueryResult<T[K]>; };
		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>; }];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { QueriesOptions, QueriesResults, useQueries };
		//# sourceMappingURL=useQueries.d.cts.map

+57

-3

build/modern/useQueries.d.ts

		@@ -1,3 +0,57 @@
		export { useQueries_alias_1 as useQueries } from './_tsup-dts-rollup.js';
		export { QueriesOptions_alias_1 as QueriesOptions } from './_tsup-dts-rollup.js';
		export { QueriesResults_alias_1 as QueriesResults } from './_tsup-dts-rollup.js';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.js";
		import { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, ThrowOnError } from "@tanstack/query-core";
		//#region src/useQueries.d.ts
		type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
		type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends (() => infer TInitialDataResult) ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;
		type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetUseQueryOptionsForUseQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetUseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseQueryResult<T[K]>; };
		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>; }];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { QueriesOptions, QueriesResults, useQueries };
		//# sourceMappingURL=useQueries.d.ts.map

+61

-101

build/modern/useQueries.js

		"use client";

		// src/useQueries.ts
		import * as React from "react";
		import {
		QueriesObserver,
		QueryObserver,
		noop,
		notifyManager
		} from "@tanstack/query-core";
		import { useQueryClient } from "./QueryClientProvider.js";
		import { useIsRestoring } from "./IsRestoringProvider.js";
		import { useQueryErrorResetBoundary } from "./QueryErrorResetBoundary.js";
		import {
		ensurePreventErrorBoundaryRetry,
		getHasError,
		useClearResetErrorBoundary
		} from "./errorBoundaryUtils.js";
		import {
		ensureSuspenseTimers,
		fetchOptimistic,
		shouldSuspend
		} from "./suspense.js";
		function useQueries({
		queries,
		...options
		}, queryClient) {
		const client = useQueryClient(queryClient);
		const isRestoring = useIsRestoring();
		const errorResetBoundary = useQueryErrorResetBoundary();
		const defaultedQueries = React.useMemo(
		() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(
		opts
		);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
		return defaultedOptions;
		}),
		[queries, client, isRestoring]
		);
		defaultedQueries.forEach((queryOptions) => {
		ensureSuspenseTimers(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
		});
		useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = React.useState(
		() => new QueriesObserver(
		client,
		defaultedQueries,
		options
		)
		);
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(
		defaultedQueries,
		options.combine
		);
		const shouldSubscribe = !isRestoring && options.subscribed !== false;
		React.useSyncExternalStore(
		React.useCallback(
		(onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop,
		[observer, shouldSubscribe]
		),
		() => observer.getCurrentResult(),
		() => observer.getCurrentResult()
		);
		React.useEffect(() => {
		observer.setQueries(
		defaultedQueries,
		options
		);
		}, [defaultedQueries, options, observer]);
		const shouldAtLeastOneSuspend = optimisticResult.some(
		(result, index) => shouldSuspend(defaultedQueries[index], result)
		);
		const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && shouldSuspend(opts, result)) {
		const queryObserver = new QueryObserver(client, opts);
		return fetchOptimistic(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) {
		throw Promise.all(suspensePromises);
		}
		const firstSingleResultWhichShouldThrow = optimisticResult.find(
		(result, index) => {
		const query = defaultedQueries[index];
		return query && getHasError({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		}
		);
		if (firstSingleResultWhichShouldThrow?.error) {
		throw firstSingleResultWhichShouldThrow.error;
		}
		return getCombinedResult(trackResult());
		import { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary } from "./errorBoundaryUtils.js";
		import { ensureSuspenseTimers, fetchOptimistic, shouldSuspend } from "./suspense.js";
		import * as React from "react";
		import { QueriesObserver, QueryObserver, noop, notifyManager } from "@tanstack/query-core";
		//#region src/useQueries.ts
		function useQueries({ queries, ...options }, queryClient) {
		const client = useQueryClient(queryClient);
		const isRestoring = useIsRestoring();
		const errorResetBoundary = useQueryErrorResetBoundary();
		const subscribed = options.subscribed !== false;
		const defaultedQueries = React.useMemo(() => queries.map((opts) => {
		const defaultedOptions = client.defaultQueryOptions(opts);
		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
		return defaultedOptions;
		}), [
		queries,
		client,
		isRestoring,
		subscribed
		]);
		defaultedQueries.forEach((queryOptions) => {
		ensureSuspenseTimers(queryOptions);
		const query = client.getQueryCache().get(queryOptions.queryHash);
		ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
		});
		useClearResetErrorBoundary(errorResetBoundary);
		const [observer] = React.useState(() => new QueriesObserver(client, defaultedQueries, options));
		const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
		const shouldSubscribe = !isRestoring && subscribed;
		React.useSyncExternalStore(React.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
		React.useEffect(() => {
		observer.setQueries(defaultedQueries, options);
		}, [
		defaultedQueries,
		options,
		observer
		]);
		const suspensePromises = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
		const opts = defaultedQueries[index];
		if (opts && shouldSuspend(opts, result)) {
		const queryObserver = new QueryObserver(client, opts);
		return fetchOptimistic(opts, queryObserver, errorResetBoundary);
		}
		return [];
		}) : [];
		if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
		const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
		const query = defaultedQueries[index];
		return query && getHasError({
		result,
		errorResetBoundary,
		throwOnError: query.throwOnError,
		query: client.getQueryCache().get(query.queryHash),
		suspense: query.suspense
		});
		});
		if (firstSingleResultWhichShouldThrow?.error) throw firstSingleResultWhichShouldThrow.error;
		return getCombinedResult(trackResult());
		}
		export {
		useQueries
		};
		//#endregion
		export { useQueries };

		//# sourceMappingURL=useQueries.js.map

+1

-1

build/modern/useQueries.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n return defaultedOptions\n }),\n [queries, client, isRestoring],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;AACA,YAAY,WAAW;AAEvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAyLA,SAAS,WAId;AAAA,EACE;AAAA,EACA,GAAG;AACL,GAOA,aACiB;AACjB,QAAM,SAAS,eAAe,WAAW;AACzC,QAAM,cAAc,eAAe;AACnC,QAAM,qBAAqB,2BAA2B;AAEtD,QAAM,mBAAyB;AAAA,IAC7B,MACE,QAAQ,IAAI,CAAC,SAAS;AACpB,YAAM,mBAAmB,OAAO;AAAA,QAC9B;AAAA,MACF;AAGA,uBAAiB,qBAAqB,cAClC,gBACA;AAEJ,aAAO;AAAA,IACT,CAAC;AAAA,IACH,CAAC,SAAS,QAAQ,WAAW;AAAA,EAC/B;AAEA,mBAAiB,QAAQ,CAAC,iBAAiB;AACzC,yBAAqB,YAAY;AACjC,UAAM,QAAQ,OAAO,cAAc,EAAE,IAAI,aAAa,SAAS;AAC/D,oCAAgC,cAAc,oBAAoB,KAAK;AAAA,EACzE,CAAC;AAED,6BAA2B,kBAAkB;AAE7C,QAAM,CAAC,QAAQ,IAAU;AAAA,IACvB,MACE,IAAI;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACJ;AAGA,QAAM,CAAC,kBAAkB,mBAAmB,WAAW,IACrD,SAAS;AAAA,IACP;AAAA,IACC,QAAoD;AAAA,EACvD;AAEF,QAAM,kBAAkB,CAAC,eAAe,QAAQ,eAAe;AAC/D,EAAM;AAAA,IACE;AAAA,MACJ,CAAC,kBACC,kBACI,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D;AAAA,MACN,CAAC,UAAU,eAAe;AAAA,IAC5B;AAAA,IACA,MAAM,SAAS,iBAAiB;AAAA,IAChC,MAAM,SAAS,iBAAiB;AAAA,EAClC;AAEA,EAAM,gBAAU,MAAM;AACpB,aAAS;AAAA,MACP;AAAA,MACA;AAAA,IACF;AAAA,EACF,GAAG,CAAC,kBAAkB,SAAS,QAAQ,CAAC;AAExC,QAAM,0BAA0B,iBAAiB;AAAA,IAAK,CAAC,QAAQ,UAC7D,cAAc,iBAAiB,KAAK,GAAG,MAAM;AAAA,EAC/C;AAEA,QAAM,mBAAmB,0BACrB,iBAAiB,QAAQ,CAAC,QAAQ,UAAU;AAC1C,UAAM,OAAO,iBAAiB,KAAK;AAEnC,QAAI,QAAQ,cAAc,MAAM,MAAM,GAAG;AACvC,YAAM,gBAAgB,IAAI,cAAc,QAAQ,IAAI;AACpD,aAAO,gBAAgB,MAAM,eAAe,kBAAkB;AAAA,IAChE;AACA,WAAO,CAAC;AAAA,EACV,CAAC,IACD,CAAC;AAEL,MAAI,iBAAiB,SAAS,GAAG;AAC/B,UAAM,QAAQ,IAAI,gBAAgB;AAAA,EACpC;AACA,QAAM,oCAAoC,iBAAiB;AAAA,IACzD,CAAC,QAAQ,UAAU;AACjB,YAAM,QAAQ,iBAAiB,KAAK;AACpC,aACE,SACA,YAAY;AAAA,QACV;AAAA,QACA;AAAA,QACA,cAAc,MAAM;AAAA,QACpB,OAAO,OAAO,cAAc,EAAE,IAAI,MAAM,SAAS;AAAA,QACjD,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IAEL;AAAA,EACF;AAEA,MAAI,mCAAmC,OAAO;AAC5C,UAAM,kCAAkC;AAAA,EAC1C;AAEA,SAAO,kBAAkB,YAAY,CAAC;AACxC;","names":[]}
		{"version":3,"file":"useQueries.js","names":[],"sources":["../../src/useQueries.ts"],"sourcesContent":["'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n 'placeholderData' \| 'subscribed'\n> & {\n placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult<TData, TError>\n : TInitialData extends TData\n ? DefinedUseQueryResult<TData, TError>\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult<TData, TError>\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/*\n QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type QueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryOptionsForUseQueries>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n [...TDepth, 1]\n >\n : ReadonlyArray<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array<UseQueryOptionsForUseQueries>\n\n/*\n QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult<T[K]> }\n\nexport function useQueries<\n T extends Array<any>,\n TCombinedResult = QueriesResults<T>,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n \| readonly [...QueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]\n combine?: (result: QueriesResults<T>) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const subscribed = options.subscribed !== false\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : subscribed\n ? 'optimistic'\n : undefined\n\n return defaultedOptions\n }),\n [queries, client, isRestoring, subscribed],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver<TCombinedResult>(\n client,\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions<TCombinedResult>).combine,\n )\n\n const shouldSubscribe = !isRestoring && subscribed\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions<TCombinedResult>,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n"],"mappings":";;;;;;;;;AA8MA,SAAgB,WAId,EACE,SACA,GAAG,WAQL,aACiB;CACjB,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,cAAc,eAAe;CACnC,MAAM,qBAAqB,2BAA2B;CACtD,MAAM,aAAa,QAAQ,eAAe;CAE1C,MAAM,mBAAmB,MAAM,cAE3B,QAAQ,KAAK,SAAS;EACpB,MAAM,mBAAmB,OAAO,oBAC9B,IACF;EAGA,iBAAiB,qBAAqB,cAClC,gBACA,aACE,eACA,KAAA;EAEN,OAAO;CACT,CAAC,GACH;EAAC;EAAS;EAAQ;EAAa;CAAU,CAC3C;CAEA,iBAAiB,SAAS,iBAAiB;EACzC,qBAAqB,YAAY;EACjC,MAAM,QAAQ,OAAO,cAAc,CAAC,CAAC,IAAI,aAAa,SAAS;EAC/D,gCAAgC,cAAc,oBAAoB,KAAK;CACzE,CAAC;CAED,2BAA2B,kBAAkB;CAE7C,MAAM,CAAC,YAAY,MAAM,eAErB,IAAI,gBACF,QACA,kBACA,OACF,CACJ;CAGA,MAAM,CAAC,kBAAkB,mBAAmB,eAC1C,SAAS,oBACP,kBACC,QAAoD,OACvD;CAEF,MAAM,kBAAkB,CAAC,eAAe;CACxC,MAAM,qBACJ,MAAM,aACH,kBACC,kBACI,SAAS,UAAU,cAAc,WAAW,aAAa,CAAC,IAC1D,MACN,CAAC,UAAU,eAAe,CAC5B,SACM,SAAS,iBAAiB,SAC1B,SAAS,iBAAiB,CAClC;CAEA,MAAM,gBAAgB;EACpB,SAAS,WACP,kBACA,OACF;CACF,GAAG;EAAC;EAAkB;EAAS;CAAQ,CAAC;CAMxC,MAAM,mBAJ0B,iBAAiB,MAAM,QAAQ,UAC7D,cAAc,iBAAiB,QAAQ,MAAM,CAGA,IAC3C,iBAAiB,SAAS,QAAQ,UAAU;EAC1C,MAAM,OAAO,iBAAiB;EAE9B,IAAI,QAAQ,cAAc,MAAM,MAAM,GAAG;GACvC,MAAM,gBAAgB,IAAI,cAAc,QAAQ,IAAI;GACpD,OAAO,gBAAgB,MAAM,eAAe,kBAAkB;EAChE;EACA,OAAO,CAAC;CACV,CAAC,IACD,CAAC;CAEL,IAAI,iBAAiB,SAAS,GAC5B,MAAM,QAAQ,IAAI,gBAAgB;CAEpC,MAAM,oCAAoC,iBAAiB,MACxD,QAAQ,UAAU;EACjB,MAAM,QAAQ,iBAAiB;EAC/B,OACE,SACA,YAAY;GACV;GACA;GACA,cAAc,MAAM;GACpB,OAAO,OAAO,cAAc,CAAC,CAAC,IAAI,MAAM,SAAS;GACjD,UAAU,MAAM;EAClB,CAAC;CAEL,CACF;CAEA,IAAI,mCAAmC,OACrC,MAAM,kCAAkC;CAG1C,OAAO,kBAAkB,YAAY,CAAC;AACxC"}

+8

-32

build/modern/useQuery.cjs

		@@ -1,36 +0,12 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useQuery.ts
		var useQuery_exports = {};
		__export(useQuery_exports, {
		useQuery: () => useQuery
		});
		module.exports = __toCommonJS(useQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useQuery.ts
		function useQuery(options, queryClient) {
		return (0, import_useBaseQuery.useBaseQuery)(options, import_query_core.QueryObserver, queryClient);
		return require_useBaseQuery.useBaseQuery(options, _tanstack_query_core.QueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useQuery
		});
		//#endregion
		exports.useQuery = useQuery;

		//# sourceMappingURL=useQuery.cjs.map

+1

-1

build/modern/useQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAA8B;AAC9B,0BAA6B;AA0CtB,SAAS,SAAS,SAA0B,aAA2B;AAC5E,aAAO,kCAAa,SAAS,iCAAe,WAAW;AACzD;","names":[]}
		{"version":3,"file":"useQuery.cjs","names":["useBaseQuery","QueryObserver"],"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;;;AA4CA,SAAgB,SAAS,SAA0B,aAA2B;CAC5E,OAAOA,qBAAAA,aAAa,SAASC,qBAAAA,eAAe,WAAW;AACzD"}

+10

-1

build/modern/useQuery.d.cts

		@@ -1,1 +0,10 @@
		export { useQuery_alias_1 as useQuery } from './_tsup-dts-rollup.cjs';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.cjs";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from "./queryOptions.cjs";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useQuery.d.ts
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		//#endregion
		export { useQuery };
		//# sourceMappingURL=useQuery.d.cts.map

+10

-1

build/modern/useQuery.d.ts

		@@ -1,1 +0,10 @@
		export { useQuery_alias_1 as useQuery } from './_tsup-dts-rollup.js';
		import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from "./types.js";
		import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from "./queryOptions.js";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useQuery.d.ts
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<TData, TError>;
		//#endregion
		export { useQuery };
		//# sourceMappingURL=useQuery.d.ts.map

+6

-7

build/modern/useQuery.js

		"use client";

		// src/useQuery.ts
		import { useBaseQuery } from "./useBaseQuery.js";
		import { QueryObserver } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		//#region src/useQuery.ts
		function useQuery(options, queryClient) {
		return useBaseQuery(options, QueryObserver, queryClient);
		return useBaseQuery(options, QueryObserver, queryClient);
		}
		export {
		useQuery
		};
		//#endregion
		export { useQuery };

		//# sourceMappingURL=useQuery.js.map

+1

-1

build/modern/useQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<NoInfer<TData>, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;AACA,SAAS,qBAAqB;AAC9B,SAAS,oBAAoB;AA0CtB,SAAS,SAAS,SAA0B,aAA2B;AAC5E,SAAO,aAAa,SAAS,eAAe,WAAW;AACzD;","names":[]}
		{"version":3,"file":"useQuery.js","names":[],"sources":["../../src/useQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseQueryResult<TData, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n"],"mappings":";;;;AA4CA,SAAgB,SAAS,SAA0B,aAA2B;CAC5E,OAAO,aAAa,SAAS,eAAe,WAAW;AACzD"}

+18

-47

build/modern/useSuspenseInfiniteQuery.cjs

		@@ -1,51 +0,22 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useSuspenseInfiniteQuery.ts
		var useSuspenseInfiniteQuery_exports = {};
		__export(useSuspenseInfiniteQuery_exports, {
		useSuspenseInfiniteQuery: () => useSuspenseInfiniteQuery
		});
		module.exports = __toCommonJS(useSuspenseInfiniteQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_suspense = require("./suspense.cjs");
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useSuspenseInfiniteQuery.ts
		function useSuspenseInfiniteQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === import_query_core.skipToken) {
		console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		}
		return (0, import_useBaseQuery.useBaseQuery)(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: import_suspense.defaultThrowOnError
		},
		import_query_core.InfiniteQueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		return require_useBaseQuery.useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: require_suspense.defaultThrowOnError,
		placeholderData: void 0
		}, _tanstack_query_core.InfiniteQueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useSuspenseInfiniteQuery
		});
		//#endregion
		exports.useSuspenseInfiniteQuery = useSuspenseInfiniteQuery;

		//# sourceMappingURL=useSuspenseInfiniteQuery.cjs.map

+1

-1

build/modern/useSuspenseInfiniteQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAAiD;AACjD,0BAA6B;AAC7B,sBAAoC;AAc7B,SAAS,yBAOd,SAOA,aAC+C;AAC/C,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,6BAAW;AAC1C,cAAQ,MAAM,uDAAuD;AAAA,IACvE;AAAA,EACF;AAEA,aAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseInfiniteQuery.cjs","names":["skipToken","useBaseQuery","defaultThrowOnError","InfiniteQueryObserver"],"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,yBAOd,SAOA,aAC+C;CAC/C,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoBA,qBAAAA,WAC/B,QAAQ,MAAM,uDAAuD;CAAA;CAIzE,OAAOC,qBAAAA,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAcC,iBAAAA;EACd,iBAAiB,KAAA;CACnB,GACAC,qBAAAA,uBACA,WACF;AACF"}

+7

-1

build/modern/useSuspenseInfiniteQuery.d.cts

		@@ -1,1 +0,7 @@
		export { useSuspenseInfiniteQuery_alias_1 as useSuspenseInfiniteQuery } from './_tsup-dts-rollup.cjs';
		import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from "./types.cjs";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseInfiniteQuery.d.ts
		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseInfiniteQuery };
		//# sourceMappingURL=useSuspenseInfiniteQuery.d.cts.map

+7

-1

build/modern/useSuspenseInfiniteQuery.d.ts

		@@ -1,1 +0,7 @@
		export { useSuspenseInfiniteQuery_alias_1 as useSuspenseInfiniteQuery } from './_tsup-dts-rollup.js';
		import { UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult } from "./types.js";
		import { DefaultError, InfiniteData, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseInfiniteQuery.d.ts
		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseInfiniteQuery };
		//# sourceMappingURL=useSuspenseInfiniteQuery.d.ts.map

+16

-22

build/modern/useSuspenseInfiniteQuery.js

		"use client";

		// src/useSuspenseInfiniteQuery.ts
		import { defaultThrowOnError } from "./suspense.js";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { InfiniteQueryObserver, skipToken } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { defaultThrowOnError } from "./suspense.js";
		//#region src/useSuspenseInfiniteQuery.ts
		function useSuspenseInfiniteQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) {
		console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		}
		return useBaseQuery(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError
		},
		InfiniteQueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
		}
		return useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError,
		placeholderData: void 0
		}, InfiniteQueryObserver, queryClient);
		}
		export {
		useSuspenseInfiniteQuery
		};
		//#endregion
		export { useSuspenseInfiniteQuery };

		//# sourceMappingURL=useSuspenseInfiniteQuery.js.map

+1

-1

build/modern/useSuspenseInfiniteQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;AACA,SAAS,uBAAuB,iBAAiB;AACjD,SAAS,oBAAoB;AAC7B,SAAS,2BAA2B;AAc7B,SAAS,yBAOd,SAOA,aAC+C;AAC/C,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,WAAW;AAC1C,cAAQ,MAAM,uDAAuD;AAAA,IACvE;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseInfiniteQuery.js","names":[],"sources":["../../src/useSuspenseInfiniteQuery.ts"],"sourcesContent":["'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData<TQueryFnData>,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult<TData, TError>\n}\n"],"mappings":";;;;;AAiBA,SAAgB,yBAOd,SAOA,aAC+C;CAC/C,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoB,WAC/B,QAAQ,MAAM,uDAAuD;CAAA;CAIzE,OAAO,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAc;EACd,iBAAiB,KAAA;CACnB,GACA,uBACA,WACF;AACF"}

+23

-52

build/modern/useSuspenseQueries.cjs

		@@ -1,56 +0,27 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useSuspenseQueries.ts
		var useSuspenseQueries_exports = {};
		__export(useSuspenseQueries_exports, {
		useSuspenseQueries: () => useSuspenseQueries
		});
		module.exports = __toCommonJS(useSuspenseQueries_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useQueries = require("./useQueries.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_suspense = require("./suspense.cjs");
		const require_useQueries = require("./useQueries.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useSuspenseQueries.ts
		function useSuspenseQueries(options, queryClient) {
		return (0, import_useQueries.useQueries)(
		{
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === import_query_core.skipToken) {
		console.error("skipToken is not allowed for useSuspenseQueries");
		}
		}
		return {
		...query,
		suspense: true,
		throwOnError: import_suspense.defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		},
		queryClient
		);
		return require_useQueries.useQueries({
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseQueries");
		}
		return {
		...query,
		suspense: true,
		throwOnError: require_suspense.defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		}, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useSuspenseQueries
		});
		//#endregion
		exports.useSuspenseQueries = useSuspenseQueries;

		//# sourceMappingURL=useSuspenseQueries.cjs.map

+1

-1

build/modern/useSuspenseQueries.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAA0B;AAC1B,wBAA2B;AAC3B,sBAAoC;AAyL7B,SAAS,mBAAmB,SAAc,aAA2B;AAC1E,aAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS,QAAQ,QAAQ,IAAI,CAAC,UAAe;AAC3C,YAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,cAAI,MAAM,YAAY,6BAAW;AAC/B,oBAAQ,MAAM,iDAAiD;AAAA,UACjE;AAAA,QACF;AAEA,eAAO;AAAA,UACL,GAAG;AAAA,UACH,UAAU;AAAA,UACV,cAAc;AAAA,UACd,SAAS;AAAA,UACT,iBAAiB;AAAA,QACnB;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQueries.cjs","names":["useQueries","skipToken","defaultThrowOnError"],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;;;;AA4LA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAOA,mBAAAA,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAYC,qBAAAA,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAcC,iBAAAA;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}

+60

-3

build/modern/useSuspenseQueries.d.cts

		@@ -1,3 +0,60 @@
		export { useSuspenseQueries_alias_1 as useSuspenseQueries } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesOptions_alias_1 as SuspenseQueriesOptions } from './_tsup-dts-rollup.cjs';
		export { SuspenseQueriesResults_alias_1 as SuspenseQueriesResults } from './_tsup-dts-rollup.cjs';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
		import { DefaultError, QueryClient, QueryFunction, ThrowOnError } from "@tanstack/query-core";
		//#region src/useSuspenseQueries.d.ts
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
		type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[...Tails], [...TResults, GetUseSuspenseQueryOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[...Tails], [...TResults, GetUseSuspenseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]>; };
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]>; }];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };
		//# sourceMappingURL=useSuspenseQueries.d.cts.map

+60

-3

build/modern/useSuspenseQueries.d.ts

		@@ -1,3 +0,60 @@
		export { useSuspenseQueries_alias_1 as useSuspenseQueries } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesOptions_alias_1 as SuspenseQueriesOptions } from './_tsup-dts-rollup.js';
		export { SuspenseQueriesResults_alias_1 as SuspenseQueriesResults } from './_tsup-dts-rollup.js';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
		import { DefaultError, QueryClient, QueryFunction, ThrowOnError } from "@tanstack/query-core";
		//#region src/useSuspenseQueries.d.ts
		type MAXIMUM_DEPTH = 20;
		type SkipTokenForUseQueries = symbol;
		type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;
		type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;
		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[...Tails], [...TResults, GetUseSuspenseQueryOptions<Head>], [...TDepth, 1]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[...Tails], [...TResults, GetUseSuspenseQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]>; };
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]>; }];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		//#endregion
		export { SuspenseQueriesOptions, SuspenseQueriesResults, useSuspenseQueries };
		//# sourceMappingURL=useSuspenseQueries.d.ts.map

+21

-27

build/modern/useSuspenseQueries.js

		"use client";

		// src/useSuspenseQueries.ts
		import { defaultThrowOnError } from "./suspense.js";
		import { useQueries } from "./useQueries.js";
		import { skipToken } from "@tanstack/query-core";
		import { useQueries } from "./useQueries.js";
		import { defaultThrowOnError } from "./suspense.js";
		//#region src/useSuspenseQueries.ts
		function useSuspenseQueries(options, queryClient) {
		return useQueries(
		{
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === skipToken) {
		console.error("skipToken is not allowed for useSuspenseQueries");
		}
		}
		return {
		...query,
		suspense: true,
		throwOnError: defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		},
		queryClient
		);
		return useQueries({
		...options,
		queries: options.queries.map((query) => {
		if (process.env.NODE_ENV !== "production") {
		if (query.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQueries");
		}
		return {
		...query,
		suspense: true,
		throwOnError: defaultThrowOnError,
		enabled: true,
		placeholderData: void 0
		};
		})
		}, queryClient);
		}
		export {
		useSuspenseQueries
		};
		//#endregion
		export { useSuspenseQueries };

		//# sourceMappingURL=useSuspenseQueries.js.map

+1

-1

build/modern/useSuspenseQueries.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;AACA,SAAS,iBAAiB;AAC1B,SAAS,kBAAkB;AAC3B,SAAS,2BAA2B;AAyL7B,SAAS,mBAAmB,SAAc,aAA2B;AAC1E,SAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS,QAAQ,QAAQ,IAAI,CAAC,UAAe;AAC3C,YAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,cAAI,MAAM,YAAY,WAAW;AAC/B,oBAAQ,MAAM,iDAAiD;AAAA,UACjE;AAAA,QACF;AAEA,eAAO;AAAA,UACL,GAAG;AAAA,UACH,UAAU;AAAA,UACV,cAAc;AAAA,UACd,SAAS;AAAA,UACT,iBAAiB;AAAA,QACnB;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQueries.js","names":[],"sources":["../../src/useSuspenseQueries.ts"],"sourcesContent":["'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions<T> =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions<unknown, TError, TData>\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions<TQueryFnData>\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, infer TQueryKey>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult<TData, TError>\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult<TData, TError>\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult<TData, TError>\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult<TQueryFnData, TError>\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult<TQueryFnData>\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n \| QueryFunction<infer TQueryFnData, any>\n \| SkipTokenForUseQueries\n throwOnError?: ThrowOnError<any, infer TError, any, any>\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/*\n SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n /\nexport type SuspenseQueriesOptions<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryOptions>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions<Head>],\n [...TDepth, 1]\n >\n : Array<unknown> extends T\n ? T\n : // If T is some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>\n >\n : // Fallback\n Array<UseSuspenseQueryOptions>\n\n/*\n SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array<any>,\n TResults extends Array<any> = [],\n TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array<UseSuspenseQueryResult>\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult<Head>]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult<Head>],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult<T[K]> }\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries:\n \| readonly [...SuspenseQueriesOptions<T>]\n \| readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array<any>,\n TCombinedResult = SuspenseQueriesResults<T>,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions<T>]\n combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n"],"mappings":";;;;;AA4LA,SAAgB,mBAAmB,SAAc,aAA2B;CAC1E,OAAO,WACL;EACE,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,UAAe;GAC3C,IAAI,QAAQ,IAAI,aAAa,cACvB;QAAA,MAAM,YAAY,WACpB,QAAQ,MAAM,iDAAiD;GAAA;GAInE,OAAO;IACL,GAAG;IACH,UAAU;IACV,cAAc;IACd,SAAS;IACT,iBAAiB,KAAA;GACnB;EACF,CAAC;CACH,GACA,WACF;AACF"}

+18

-48

build/modern/useSuspenseQuery.cjs

		@@ -1,52 +0,22 @@
		"use strict";
		"use client";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return to;
		};
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/useSuspenseQuery.ts
		var useSuspenseQuery_exports = {};
		__export(useSuspenseQuery_exports, {
		useSuspenseQuery: () => useSuspenseQuery
		});
		module.exports = __toCommonJS(useSuspenseQuery_exports);
		var import_query_core = require("@tanstack/query-core");
		var import_useBaseQuery = require("./useBaseQuery.cjs");
		var import_suspense = require("./suspense.cjs");
		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
		const require_suspense = require("./suspense.cjs");
		const require_useBaseQuery = require("./useBaseQuery.cjs");
		let _tanstack_query_core = require("@tanstack/query-core");
		//#region src/useSuspenseQuery.ts
		function useSuspenseQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === import_query_core.skipToken) {
		console.error("skipToken is not allowed for useSuspenseQuery");
		}
		}
		return (0, import_useBaseQuery.useBaseQuery)(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: import_suspense.defaultThrowOnError,
		placeholderData: void 0
		},
		import_query_core.QueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === _tanstack_query_core.skipToken) console.error("skipToken is not allowed for useSuspenseQuery");
		}
		return require_useBaseQuery.useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: require_suspense.defaultThrowOnError,
		placeholderData: void 0
		}, _tanstack_query_core.QueryObserver, queryClient);
		}
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		useSuspenseQuery
		});
		//#endregion
		exports.useSuspenseQuery = useSuspenseQuery;

		//# sourceMappingURL=useSuspenseQuery.cjs.map

+1

-1

build/modern/useSuspenseQuery.cjs.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,wBAAyC;AACzC,0BAA6B;AAC7B,sBAAoC;AAI7B,SAAS,iBAMd,SACA,aACuC;AACvC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,6BAAW;AAC1C,cAAQ,MAAM,+CAA+C;AAAA,IAC/D;AAAA,EACF;AAEA,aAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,MACd,iBAAiB;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQuery.cjs","names":["skipToken","useBaseQuery","defaultThrowOnError","QueryObserver"],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;;AAOA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoBA,qBAAAA,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAOC,qBAAAA,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAcC,iBAAAA;EACd,iBAAiB,KAAA;CACnB,GACAC,qBAAAA,eACA,WACF;AACF"}

+7

-1

build/modern/useSuspenseQuery.d.cts

		@@ -1,1 +0,7 @@
		export { useSuspenseQuery_alias_1 as useSuspenseQuery } from './_tsup-dts-rollup.cjs';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.cjs";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseQuery.d.ts
		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseQuery };
		//# sourceMappingURL=useSuspenseQuery.d.cts.map

+7

-1

build/modern/useSuspenseQuery.d.ts

		@@ -1,1 +0,7 @@
		export { useSuspenseQuery_alias_1 as useSuspenseQuery } from './_tsup-dts-rollup.js';
		import { UseSuspenseQueryOptions, UseSuspenseQueryResult } from "./types.js";
		import { DefaultError, QueryClient, QueryKey } from "@tanstack/query-core";
		//#region src/useSuspenseQuery.d.ts
		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		//#endregion
		export { useSuspenseQuery };
		//# sourceMappingURL=useSuspenseQuery.d.ts.map

+16

-23

build/modern/useSuspenseQuery.js

		"use client";

		// src/useSuspenseQuery.ts
		import { defaultThrowOnError } from "./suspense.js";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { QueryObserver, skipToken } from "@tanstack/query-core";
		import { useBaseQuery } from "./useBaseQuery.js";
		import { defaultThrowOnError } from "./suspense.js";
		//#region src/useSuspenseQuery.ts
		function useSuspenseQuery(options, queryClient) {
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) {
		console.error("skipToken is not allowed for useSuspenseQuery");
		}
		}
		return useBaseQuery(
		{
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError,
		placeholderData: void 0
		},
		QueryObserver,
		queryClient
		);
		if (process.env.NODE_ENV !== "production") {
		if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQuery");
		}
		return useBaseQuery({
		...options,
		enabled: true,
		suspense: true,
		throwOnError: defaultThrowOnError,
		placeholderData: void 0
		}, QueryObserver, queryClient);
		}
		export {
		useSuspenseQuery
		};
		//#endregion
		export { useSuspenseQuery };

		//# sourceMappingURL=useSuspenseQuery.js.map

+1

-1

build/modern/useSuspenseQuery.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;AACA,SAAS,eAAe,iBAAiB;AACzC,SAAS,oBAAoB;AAC7B,SAAS,2BAA2B;AAI7B,SAAS,iBAMd,SACA,aACuC;AACvC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAK,QAAQ,YAAoB,WAAW;AAC1C,cAAQ,MAAM,+CAA+C;AAAA,IAC/D;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,MACE,GAAG;AAAA,MACH,SAAS;AAAA,MACT,UAAU;AAAA,MACV,cAAc;AAAA,MACd,iBAAiB;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}
		{"version":3,"file":"useSuspenseQuery.js","names":[],"sources":["../../src/useSuspenseQuery.ts"],"sourcesContent":["'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult<TData, TError>\n}\n"],"mappings":";;;;;AAOA,SAAgB,iBAMd,SACA,aACuC;CACvC,IAAI,QAAQ,IAAI,aAAa,cACtB;MAAA,QAAQ,YAAoB,WAC/B,QAAQ,MAAM,+CAA+C;CAAA;CAIjE,OAAO,aACL;EACE,GAAG;EACH,SAAS;EACT,UAAU;EACV,cAAc;EACd,iBAAiB,KAAA;CACnB,GACA,eACA,WACF;AACF"}

+1

-1

build/query-codemods/root.eslint.config.js

		@@ -35,3 +35,3 @@ // @ts-check
		'tsqd', // Our public interface (TanStack Query Devtools shorthand)
		'tsup', // We use tsup as builder
		'tsdown', // We use tsdown as builder
		'typecheck', // Field of vite.config.ts
		@@ -38,0 +38,0 @@ 'vue-demi', // dependency of @tanstack/vue-query

+6

-8

package.json

		{
		"name": "@tanstack/react-query",
		"version": "5.101.4",
		"version": "5.102.0",
		"description": "Hooks for managing, caching and syncing asynchronous and remote data in React",
		@@ -47,3 +47,3 @@ "author": "tannerlinsley",
		"dependencies": {
		"@tanstack/query-core": "5.101.4"
		"@tanstack/query-core": "5.102.0"
		},
		@@ -61,3 +61,3 @@ "devDependencies": {
		"react-error-boundary": "^4.1.2",
		"@tanstack/query-persist-client-core": "5.101.4",
		"@tanstack/query-persist-client-core": "5.102.0",
		"@tanstack/query-test-utils": "0.0.0"
		@@ -73,4 +73,2 @@ },
		"test:types": "npm-run-all --serial test:types:*",
		"test:types:ts54": "node ../../node_modules/typescript54/lib/tsc.js --build tsconfig.legacy.json",
		"test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js --build tsconfig.legacy.json",
		"test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js --build tsconfig.legacy.json",
		@@ -81,10 +79,10 @@ "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js --build tsconfig.legacy.json",
		"test:types:tscurrent": "tsc --build",
		"test:types:ts60": "node ../../node_modules/typescript60/lib/tsc.js --build",
		"test:types:ts70": "node ../../node_modules/typescript70/lib/tsc.js --build",
		"test:lib": "vitest",
		"test:lib:dev": "pnpm run test:lib --watch",
		"test:build": "publint --strict && attw --pack",
		"build": "pnpm build:tsup && pnpm build:codemods",
		"build:tsup": "tsup --tsconfig tsconfig.prod.json",
		"build": "pnpm build:tsdown && pnpm build:codemods",
		"build:tsdown": "tsdown --tsconfig tsconfig.prod.json",
		"build:codemods": "cpy ../query-codemods/* ./build/codemods"
		}
		}

+15

-1

README.md

		<img src="https://static.scarf.sh/a.png?x-pxid=be2d8a11-9712-4c1d-9963-580b2d4fb133" />

		![TanStack Query Header](https://github.com/TanStack/query/raw/main/media/repo-header.png)
		<picture>
		<source
		media="(prefers-color-scheme: dark)"
		srcset="https://tanstack.com/api/readme/query.png?framework=react&theme=dark"
		/>
		<source
		media="(prefers-color-scheme: light)"
		srcset="https://tanstack.com/api/readme/query.png?framework=react"
		/>
		<img
		src="https://tanstack.com/api/readme/query.png?framework=react"
		alt="TanStack React Query"
		width="900"
		/>
		</picture>

		@@ -5,0 +19,0 @@ Hooks for fetching, caching and updating asynchronous data in React

+1

-5

src/errorBoundaryUtils.ts

		@@ -35,7 +35,3 @@ 'use client'

		if (
		options.suspense \|\|
		options.experimental_prefetchInRender \|\|
		throwOnError
		) {
		if (options.suspense \|\| throwOnError) {
		// Prevent retrying failed query if the error boundary has not been reset yet
		@@ -42,0 +38,0 @@ if (!errorResetBoundary.isReset()) {

+1

-1

src/index.ts

		@@ -7,3 +7,3 @@ /* istanbul ignore file */
		// React Query
		export * from './types'
		export type * from './types'
		export { useQueries } from './useQueries'
		@@ -10,0 +10,0 @@ export type { QueriesResults, QueriesOptions } from './useQueries'

+7

-10

src/infiniteQueryOptions.ts

		import type {
		DataTag,
		DefaultError,
		@@ -9,2 +8,3 @@ InfiniteData,
		QueryKey,
		QueryKeyWithDataTag,
		SkipToken,
		@@ -96,5 +96,4 @@ } from '@tanstack/query-core'
		TPageParam
		> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
		}
		> &
		QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>

		@@ -121,5 +120,4 @@ export function infiniteQueryOptions<
		TPageParam
		> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
		}
		> &
		QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>

		@@ -146,5 +144,4 @@ export function infiniteQueryOptions<
		TPageParam
		> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
		}
		> &
		QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>

		@@ -151,0 +148,0 @@ export function infiniteQueryOptions(options: unknown) {

+7

-10

src/queryOptions.ts

		import type {
		DataTag,
		DefaultError,
		@@ -9,2 +8,3 @@ InitialDataFunction,
		QueryKey,
		QueryKeyWithDataTag,
		SkipToken,
		@@ -60,5 +60,4 @@ } from '@tanstack/query-core'
		options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
		): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>
		}
		): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &
		QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>

		@@ -72,5 +71,4 @@ export function queryOptions<
		options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>,
		): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>
		}
		): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> &
		QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>

		@@ -84,5 +82,4 @@ export function queryOptions<
		options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
		): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>
		}
		): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> &
		QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>

		@@ -89,0 +86,0 @@ export function queryOptions(options: unknown) {

+0

-5

src/suspense.ts

		@@ -49,7 +49,2 @@ import type {

		export const willFetch = (
		result: QueryObserverResult<any, any>,
		isRestoring: boolean,
		) => result.isLoading && result.isFetching && !isRestoring

		export const shouldSuspend = (
		@@ -56,0 +51,0 @@ defaultedOptions:

+47

-10

src/types.ts

		@@ -8,3 +8,4 @@ /* istanbul ignore file */
		DistributiveOmit,
		FetchQueryOptions,
		InfiniteData,
		InfiniteQueryExecuteOptions,
		InfiniteQueryObserverOptions,
		@@ -17,2 +18,3 @@ InfiniteQueryObserverResult,
		Override,
		QueryExecuteOptions,
		QueryKey,
		@@ -51,13 +53,20 @@ QueryObserverOptions,

		export interface UsePrefetchQueryOptions<
		export type UsePrefetchQueryOptions<
		TQueryFnData = unknown,
		TError = DefaultError,
		TData = TQueryFnData,
		TQueryData = TQueryFnData,
		TQueryKey extends QueryKey = QueryKey,
		> extends OmitKeyof<
		FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
		> = DistributiveOmit<
		QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,
		'queryFn'
		> {
		> & {
		queryFn?: Exclude<
		FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'],
		QueryExecuteOptions<
		TQueryFnData,
		TError,
		TData,
		TQueryData,
		TQueryKey
		>['queryFn'],
		SkipToken
		@@ -67,2 +76,30 @@ >

		export type UsePrefetchInfiniteQueryOptions<
		TQueryFnData = unknown,
		TError = DefaultError,
		TData = InfiniteData<TQueryFnData>,
		TQueryKey extends QueryKey = QueryKey,
		TPageParam = unknown,
		> = DistributiveOmit<
		InfiniteQueryExecuteOptions<
		TQueryFnData,
		TError,
		TData,
		TQueryKey,
		TPageParam
		>,
		'queryFn'
		> & {
		queryFn?: Exclude<
		InfiniteQueryExecuteOptions<
		TQueryFnData,
		TError,
		TData,
		TQueryKey,
		TPageParam
		>['queryFn'],
		SkipToken
		>
		}

		export type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>
		@@ -110,3 +147,3 @@ export interface UseQueryOptions<
		TError = DefaultError,
		TData = TQueryFnData,
		TData = InfiniteData<TQueryFnData>,
		TQueryKey extends QueryKey = QueryKey,
		@@ -136,3 +173,3 @@ TPageParam = unknown,
		TError = DefaultError,
		TData = TQueryFnData,
		TData = InfiniteData<TQueryFnData>,
		TQueryKey extends QueryKey = QueryKey,
		@@ -171,3 +208,3 @@ TPageParam = unknown,
		DefinedQueryObserverResult<TData, TError>,
		'isPlaceholderData' \| 'promise'
		'isPlaceholderData'
		>
		@@ -195,3 +232,3 @@
		DefinedInfiniteQueryObserverResult<TData, TError>,
		'isPlaceholderData' \| 'promise'
		'isPlaceholderData'
		>
		@@ -198,0 +235,0 @@

+1

-32

src/useBaseQuery.ts

		'use client'
		import * as React from 'react'

		import { environmentManager, noop, notifyManager } from '@tanstack/query-core'
		import { noop, notifyManager } from '@tanstack/query-core'
		import { useQueryClient } from './QueryClientProvider'
		@@ -17,3 +17,2 @@ import { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'
		shouldSuspend,
		willFetch,
		} from './suspense'
		@@ -57,5 +56,2 @@ import type {
		const defaultedOptions = client.defaultQueryOptions(options)
		;(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(
		defaultedOptions,
		)

		@@ -92,7 +88,2 @@ const query = client

		// this needs to be invoked before creating the Observer because that can create a cache entry
		const isNewCacheEntry = !client
		.getQueryCache()
		.get(defaultedOptions.queryHash)

		const [observer] = React.useState(
		@@ -151,24 +142,2 @@ () =>

		;(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(
		defaultedOptions,
		result,
		)

		if (
		defaultedOptions.experimental_prefetchInRender &&
		!environmentManager.isServer() &&
		willFetch(result, isRestoring)
		) {
		const promise = isNewCacheEntry
		? // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
		fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
		: // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
		query?.promise

		promise?.catch(noop).finally(() => {
		// `.updateResult()` will trigger `.#currentThenable` to finalize
		observer.updateResult()
		})
		}

		// Handle result property usage tracking
		@@ -175,0 +144,0 @@ return !defaultedOptions.notifyOnChangeProps

+6

-2

src/useMutation.ts

		@@ -55,4 +55,8 @@ 'use client'
		>(
		(variables, mutateOptions) => {
		observer.mutate(variables, mutateOptions).catch(noop)
		(
		...args: Parameters<
		UseMutateFunction<TData, TError, TVariables, TOnMutateResult>
		>
		) => {
		observer.mutate(args[0] as TVariables, args[1]).catch(noop)
		},
		@@ -59,0 +63,0 @@ [observer],

+32

-7

src/useMutationState.ts

		@@ -25,10 +25,29 @@ 'use client'

		type MutationStateOptions<TResult = MutationState> = {
		type MutationTypeFromResult<TResult> = [TResult] extends [
		MutationState<
		infer TData,
		infer TError,
		infer TVariables,
		infer TOnMutateResult
		>,
		]
		? Mutation<TData, TError, TVariables, TOnMutateResult>
		: Mutation

		type MutationStateOptions<
		TResult = MutationState,
		TMutation extends Mutation<any, any, any, any> =
		MutationTypeFromResult<TResult>,
		> = {
		filters?: MutationFilters
		select?: (mutation: Mutation) => TResult
		select?: (mutation: TMutation) => TResult
		}

		function getResult<TResult = MutationState>(
		function getResult<
		TResult = MutationState,
		TMutation extends Mutation<any, any, any, any> =
		MutationTypeFromResult<TResult>,
		>(
		mutationCache: MutationCache,
		options: MutationStateOptions<TResult>,
		options: MutationStateOptions<TResult, TMutation>,
		): Array<TResult> {
		@@ -39,8 +58,14 @@ return mutationCache
		(mutation): TResult =>
		(options.select ? options.select(mutation) : mutation.state) as TResult,
		(options.select
		? options.select(mutation as TMutation)
		: mutation.state) as TResult,
		)
		}

		export function useMutationState<TResult = MutationState>(
		options: MutationStateOptions<TResult> = {},
		export function useMutationState<
		TResult = MutationState,
		TMutation extends Mutation<any, any, any, any> =
		MutationTypeFromResult<TResult>,
		>(
		options: MutationStateOptions<TResult, TMutation> = {},
		queryClient?: QueryClient,
		@@ -47,0 +72,0 @@ ): Array<TResult> {

+8

-5

src/usePrefetchInfiniteQuery.tsx

		@@ -0,8 +1,11 @@
		import { noop } from '@tanstack/query-core'
		import { useQueryClient } from './QueryClientProvider'

		import type {
		DefaultError,
		FetchInfiniteQueryOptions,
		InfiniteData,
		QueryClient,
		QueryKey,
		} from '@tanstack/query-core'
		import type { UsePrefetchInfiniteQueryOptions } from './types'

		@@ -12,7 +15,7 @@ export function usePrefetchInfiniteQuery<
		TError = DefaultError,
		TData = TQueryFnData,
		TData = InfiniteData<TQueryFnData>,
		TQueryKey extends QueryKey = QueryKey,
		TPageParam = unknown,
		>(
		options: FetchInfiniteQueryOptions<
		options: UsePrefetchInfiniteQueryOptions<
		TQueryFnData,
		@@ -25,8 +28,8 @@ TError,
		queryClient?: QueryClient,
		) {
		): void {
		const client = useQueryClient(queryClient)

		if (!client.getQueryState(options.queryKey)) {
		client.prefetchInfiniteQuery(options)
		void client.infiniteQuery(options).catch(noop)
		}
		}

+12

-3

src/usePrefetchQuery.tsx

		@@ -0,2 +1,4 @@
		import { noop } from '@tanstack/query-core'
		import { useQueryClient } from './QueryClientProvider'

		import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
		@@ -9,12 +11,19 @@ import type { UsePrefetchQueryOptions } from './types'
		TData = TQueryFnData,
		TQueryData = TQueryFnData,
		TQueryKey extends QueryKey = QueryKey,
		>(
		options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
		options: UsePrefetchQueryOptions<
		TQueryFnData,
		TError,
		TData,
		TQueryData,
		TQueryKey
		>,
		queryClient?: QueryClient,
		) {
		): void {
		const client = useQueryClient(queryClient)

		if (!client.getQueryState(options.queryKey)) {
		client.prefetchQuery(options)
		void client.query(options).catch(noop)
		}
		}

+6

-3

src/useQueries.ts

		@@ -226,2 +226,3 @@ 'use client'
		const errorResetBoundary = useQueryErrorResetBoundary()
		const subscribed = options.subscribed !== false

		@@ -238,7 +239,9 @@ const defaultedQueries = React.useMemo(
		? 'isRestoring'
		: 'optimistic'
		: subscribed
		? 'optimistic'
		: undefined

		return defaultedOptions
		}),
		[queries, client, isRestoring],
		[queries, client, isRestoring, subscribed],
		)
		@@ -270,3 +273,3 @@

		const shouldSubscribe = !isRestoring && options.subscribed !== false
		const shouldSubscribe = !isRestoring && subscribed
		React.useSyncExternalStore(
		@@ -273,0 +276,0 @@ React.useCallback(

+3

-3

src/useQuery.ts

		@@ -23,3 +23,3 @@ 'use client'
		queryClient?: QueryClient,
		): DefinedUseQueryResult<NoInfer<TData>, TError>
		): DefinedUseQueryResult<TData, TError>

		@@ -34,3 +34,3 @@ export function useQuery<
		queryClient?: QueryClient,
		): UseQueryResult<NoInfer<TData>, TError>
		): UseQueryResult<TData, TError>

		@@ -45,3 +45,3 @@ export function useQuery<
		queryClient?: QueryClient,
		): UseQueryResult<NoInfer<TData>, TError>
		): UseQueryResult<TData, TError>

		@@ -48,0 +48,0 @@ export function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {

+1

-0

src/useSuspenseInfiniteQuery.ts

		@@ -46,2 +46,3 @@ 'use client'
		throwOnError: defaultThrowOnError,
		placeholderData: undefined,
		},
		@@ -48,0 +49,0 @@ InfiniteQueryObserver as typeof QueryObserver,

-947

build/legacy/_tsup-dts-rollup.d.cts

		import { AnyDataTag } from '@tanstack/query-core';
		import { CancelledError } from '@tanstack/query-core';
		import { CancelOptions } from '@tanstack/query-core';
		import { DataTag } from '@tanstack/query-core';
		import { dataTagErrorSymbol } from '@tanstack/query-core';
		import { dataTagSymbol } from '@tanstack/query-core';
		import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultError } from '@tanstack/query-core';
		import { DefaultOptions } from '@tanstack/query-core';
		import { defaultScheduler } from '@tanstack/query-core';
		import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
		import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
		import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
		import { DefinedQueryObserverResult } from '@tanstack/query-core';
		import { dehydrate } from '@tanstack/query-core';
		import { DehydratedState } from '@tanstack/query-core';
		import { DehydrateOptions } from '@tanstack/query-core';
		import { DistributiveOmit } from '@tanstack/query-core';
		import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
		import { EnsureQueryDataOptions } from '@tanstack/query-core';
		import { environmentManager } from '@tanstack/query-core';
		import { experimental_streamedQuery } from '@tanstack/query-core';
		import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
		import { FetchNextPageOptions } from '@tanstack/query-core';
		import { FetchPreviousPageOptions } from '@tanstack/query-core';
		import { FetchQueryOptions } from '@tanstack/query-core';
		import { FetchStatus } from '@tanstack/query-core';
		import { focusManager } from '@tanstack/query-core';
		import { GetNextPageParamFunction } from '@tanstack/query-core';
		import { GetPreviousPageParamFunction } from '@tanstack/query-core';
		import { hashKey } from '@tanstack/query-core';
		import { hydrate } from '@tanstack/query-core';
		import { HydrateOptions } from '@tanstack/query-core';
		import { InferDataFromTag } from '@tanstack/query-core';
		import { InferErrorFromTag } from '@tanstack/query-core';
		import { InfiniteData } from '@tanstack/query-core';
		import { InfiniteQueryObserver } from '@tanstack/query-core';
		import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
		import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
		import { InitialDataFunction } from '@tanstack/query-core';
		import { InitialPageParam } from '@tanstack/query-core';
		import { InvalidateOptions } from '@tanstack/query-core';
		import { InvalidateQueryFilters } from '@tanstack/query-core';
		import { isCancelledError } from '@tanstack/query-core';
		import { isServer } from '@tanstack/query-core';
		import { JSX } from 'react/jsx-runtime';
		import { keepPreviousData } from '@tanstack/query-core';
		import { ManagedTimerId } from '@tanstack/query-core';
		import { matchMutation } from '@tanstack/query-core';
		import { matchQuery } from '@tanstack/query-core';
		import { MutateFunction } from '@tanstack/query-core';
		import { MutateOptions } from '@tanstack/query-core';
		import { Mutation } from '@tanstack/query-core';
		import { MutationCache } from '@tanstack/query-core';
		import { MutationCacheNotifyEvent } from '@tanstack/query-core';
		import { MutationFilters } from '@tanstack/query-core';
		import { MutationFunction } from '@tanstack/query-core';
		import { MutationFunctionContext } from '@tanstack/query-core';
		import { MutationKey } from '@tanstack/query-core';
		import { MutationMeta } from '@tanstack/query-core';
		import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
		import { MutationObserverBaseResult } from '@tanstack/query-core';
		import { MutationObserverErrorResult } from '@tanstack/query-core';
		import { MutationObserverIdleResult } from '@tanstack/query-core';
		import { MutationObserverLoadingResult } from '@tanstack/query-core';
		import { MutationObserverOptions } from '@tanstack/query-core';
		import { MutationObserverResult } from '@tanstack/query-core';
		import { MutationObserverSuccessResult } from '@tanstack/query-core';
		import { MutationOptions } from '@tanstack/query-core';
		import { MutationScope } from '@tanstack/query-core';
		import { MutationState } from '@tanstack/query-core';
		import { MutationStatus } from '@tanstack/query-core';
		import { NetworkMode } from '@tanstack/query-core';
		import { NonUndefinedGuard } from '@tanstack/query-core';
		import { noop } from '@tanstack/query-core';
		import { NotifyEvent } from '@tanstack/query-core';
		import { NotifyEventType } from '@tanstack/query-core';
		import { notifyManager } from '@tanstack/query-core';
		import { NotifyOnChangeProps } from '@tanstack/query-core';
		import { OmitKeyof } from '@tanstack/query-core';
		import { onlineManager } from '@tanstack/query-core';
		import { Override } from '@tanstack/query-core';
		import { partialMatchKey } from '@tanstack/query-core';
		import { PlaceholderDataFunction } from '@tanstack/query-core';
		import { QueriesObserver } from '@tanstack/query-core';
		import { QueriesObserverOptions } from '@tanstack/query-core';
		import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
		import { Query } from '@tanstack/query-core';
		import { QueryBooleanOption } from '@tanstack/query-core';
		import { QueryCache } from '@tanstack/query-core';
		import { QueryCacheNotifyEvent } from '@tanstack/query-core';
		import { QueryClient } from '@tanstack/query-core';
		import { QueryClientConfig } from '@tanstack/query-core';
		import { QueryFilters } from '@tanstack/query-core';
		import { QueryFunction } from '@tanstack/query-core';
		import { QueryFunctionContext } from '@tanstack/query-core';
		import { QueryKey } from '@tanstack/query-core';
		import { QueryKeyHashFunction } from '@tanstack/query-core';
		import { QueryMeta } from '@tanstack/query-core';
		import { QueryObserver } from '@tanstack/query-core';
		import { QueryObserverBaseResult } from '@tanstack/query-core';
		import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { QueryObserverLoadingResult } from '@tanstack/query-core';
		import { QueryObserverOptions } from '@tanstack/query-core';
		import { QueryObserverPendingResult } from '@tanstack/query-core';
		import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { QueryObserverResult } from '@tanstack/query-core';
		import { QueryObserverSuccessResult } from '@tanstack/query-core';
		import { QueryOptions } from '@tanstack/query-core';
		import { QueryPersister } from '@tanstack/query-core';
		import { QueryState } from '@tanstack/query-core';
		import { QueryStatus } from '@tanstack/query-core';
		import * as React_2 from 'react';
		import { RefetchOptions } from '@tanstack/query-core';
		import { RefetchQueryFilters } from '@tanstack/query-core';
		import { Register } from '@tanstack/query-core';
		import { replaceEqualDeep } from '@tanstack/query-core';
		import { ResetOptions } from '@tanstack/query-core';
		import { ResultOptions } from '@tanstack/query-core';
		import { SetDataOptions } from '@tanstack/query-core';
		import { shouldThrowError } from '@tanstack/query-core';
		import { SkipToken } from '@tanstack/query-core';
		import { skipToken } from '@tanstack/query-core';
		import { StaleTime } from '@tanstack/query-core';
		import { StaleTimeFunction } from '@tanstack/query-core';
		import { ThrowOnError } from '@tanstack/query-core';
		import { TimeoutCallback } from '@tanstack/query-core';
		import { timeoutManager } from '@tanstack/query-core';
		import { TimeoutProvider } from '@tanstack/query-core';
		import { UnsetMarker } from '@tanstack/query-core';
		import { unsetMarker } from '@tanstack/query-core';
		import { Updater } from '@tanstack/query-core';
		import { WithRequired } from '@tanstack/query-core';

		export { AnyDataTag }

		declare type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		export { AnyUseBaseQueryOptions }
		export { AnyUseBaseQueryOptions as AnyUseBaseQueryOptions_alias_1 }

		declare type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseInfiniteQueryOptions }
		export { AnyUseInfiniteQueryOptions as AnyUseInfiniteQueryOptions_alias_1 }

		declare type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		export { AnyUseMutationOptions }
		export { AnyUseMutationOptions as AnyUseMutationOptions_alias_1 }

		declare type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		export { AnyUseQueryOptions }
		export { AnyUseQueryOptions as AnyUseQueryOptions_alias_1 }

		declare type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseSuspenseInfiniteQueryOptions }
		export { AnyUseSuspenseInfiniteQueryOptions as AnyUseSuspenseInfiniteQueryOptions_alias_1 }

		declare type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		export { AnyUseSuspenseQueryOptions }
		export { AnyUseSuspenseQueryOptions as AnyUseSuspenseQueryOptions_alias_1 }

		export { CancelledError }

		export { CancelOptions }

		export { DataTag }

		export { dataTagErrorSymbol }

		export { dataTagSymbol }

		export { DefaultedInfiniteQueryObserverOptions }

		export { DefaultedQueryObserverOptions }

		export { DefaultError }

		export { DefaultOptions }

		export { defaultScheduler }

		export { defaultShouldDehydrateMutation }

		export { defaultShouldDehydrateQuery }

		export declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;

		export { DefinedInfiniteQueryObserverResult }

		declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		export { DefinedInitialDataInfiniteOptions }
		export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }

		declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		export { DefinedInitialDataOptions }
		export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }

		export { DefinedQueryObserverResult }

		declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		export { DefinedUseInfiniteQueryResult }
		export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }

		declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		export { DefinedUseQueryResult }
		export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }

		export { dehydrate }

		export { DehydratedState }

		export { DehydrateOptions }

		export { DistributiveOmit }

		export { EnsureInfiniteQueryDataOptions }

		export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;

		export { EnsureQueryDataOptions }

		export declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;

		export { environmentManager }

		export { experimental_streamedQuery }

		export { FetchInfiniteQueryOptions }

		export { FetchNextPageOptions }

		export declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;

		export { FetchPreviousPageOptions }

		export { FetchQueryOptions }

		export { FetchStatus }

		export { focusManager }

		declare type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;

		export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense, }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;

		export { GetNextPageParamFunction }

		export { GetPreviousPageParamFunction }

		declare type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;

		declare type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;

		declare type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;

		declare type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;

		export { hashKey }

		export { hydrate }

		export { HydrateOptions }

		declare const HydrationBoundary: ({ children, options, state, queryClient, }: HydrationBoundaryProps) => React_2.ReactElement;
		export { HydrationBoundary }
		export { HydrationBoundary as HydrationBoundary_alias_1 }

		declare interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React_2.ReactNode;
		queryClient?: QueryClient;
		}
		export { HydrationBoundaryProps }
		export { HydrationBoundaryProps as HydrationBoundaryProps_alias_1 }

		export { InferDataFromTag }

		export { InferErrorFromTag }

		export { InfiniteData }

		export { InfiniteQueryObserver }

		export { InfiniteQueryObserverBaseResult }

		export { InfiniteQueryObserverLoadingErrorResult }

		export { InfiniteQueryObserverLoadingResult }

		export { InfiniteQueryObserverOptions }

		export { InfiniteQueryObserverPendingResult }

		export { InfiniteQueryObserverPlaceholderResult }

		export { InfiniteQueryObserverRefetchErrorResult }

		export { InfiniteQueryObserverResult }

		export { InfiniteQueryObserverSuccessResult }

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};
		export { infiniteQueryOptions }
		export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }

		export { InfiniteQueryPageParamsOptions }

		export { InitialDataFunction }

		export { InitialPageParam }

		export { InvalidateOptions }

		export { InvalidateQueryFilters }

		export { isCancelledError }

		declare const IsRestoringProvider: React_2.Provider<boolean>;
		export { IsRestoringProvider }
		export { IsRestoringProvider as IsRestoringProvider_alias_1 }

		export { isServer }

		export { keepPreviousData }

		export { ManagedTimerId }

		export { matchMutation }

		export { matchQuery }

		declare type MAXIMUM_DEPTH = 20;

		declare type MAXIMUM_DEPTH_2 = 20;

		export { MutateFunction }

		export { MutateOptions }

		export { Mutation }

		export { MutationCache }

		export { MutationCacheNotifyEvent }

		export { MutationFilters }

		export { MutationFunction }

		export { MutationFunctionContext }

		export { MutationKey }

		export { MutationMeta }

		export { MutationObserver_2 as MutationObserver }

		export { MutationObserverBaseResult }

		export { MutationObserverErrorResult }

		export { MutationObserverIdleResult }

		export { MutationObserverLoadingResult }

		export { MutationObserverOptions }

		export { MutationObserverResult }

		export { MutationObserverSuccessResult }

		export { MutationOptions }

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		export { mutationOptions }
		export { mutationOptions as mutationOptions_alias_1 }

		export { MutationScope }

		export { MutationState }

		declare type MutationStateOptions<TResult = MutationState> = {
		filters?: MutationFilters;
		select?: (mutation: Mutation) => TResult;
		};

		export { MutationStatus }

		export { NetworkMode }

		export { NonUndefinedGuard }

		export { noop }

		export { NotifyEvent }

		export { NotifyEventType }

		export { notifyManager }

		export { NotifyOnChangeProps }

		export { OmitKeyof }

		export { onlineManager }

		export { Override }

		export { partialMatchKey }

		export { PlaceholderDataFunction }

		export { QueriesObserver }

		export { QueriesObserverOptions }

		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseQueryOptionsForUseQueries<Head>
		], [
		...TDepth,
		1
		]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		export { QueriesOptions }
		export { QueriesOptions as QueriesOptions_alias_1 }

		export { QueriesPlaceholderDataFunction }

		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		declare type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseQueryResult<T[K]>;
		};
		export { QueriesResults }
		export { QueriesResults as QueriesResults_alias_1 }

		export { Query }

		export { QueryBooleanOption }

		export { QueryCache }

		export { QueryCacheNotifyEvent }

		export { QueryClient }

		export { QueryClientConfig }

		declare const QueryClientContext: React_2.Context<QueryClient \| undefined>;
		export { QueryClientContext }
		export { QueryClientContext as QueryClientContext_alias_1 }

		declare const QueryClientProvider: ({ client, children, }: QueryClientProviderProps) => React_2.JSX.Element;
		export { QueryClientProvider }
		export { QueryClientProvider as QueryClientProvider_alias_1 }

		declare type QueryClientProviderProps = {
		client: QueryClient;
		children?: React_2.ReactNode;
		};
		export { QueryClientProviderProps }
		export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }

		declare type QueryErrorClearResetFunction = () => void;
		export { QueryErrorClearResetFunction }
		export { QueryErrorClearResetFunction as QueryErrorClearResetFunction_alias_1 }

		declare type QueryErrorIsResetFunction = () => boolean;
		export { QueryErrorIsResetFunction }
		export { QueryErrorIsResetFunction as QueryErrorIsResetFunction_alias_1 }

		declare const QueryErrorResetBoundary: ({ children, }: QueryErrorResetBoundaryProps) => JSX.Element;
		export { QueryErrorResetBoundary }
		export { QueryErrorResetBoundary as QueryErrorResetBoundary_alias_1 }

		declare type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React_2.ReactNode;
		export { QueryErrorResetBoundaryFunction }
		export { QueryErrorResetBoundaryFunction as QueryErrorResetBoundaryFunction_alias_1 }

		declare interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React_2.ReactNode;
		}
		export { QueryErrorResetBoundaryProps }
		export { QueryErrorResetBoundaryProps as QueryErrorResetBoundaryProps_alias_1 }

		export declare interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}

		declare type QueryErrorResetFunction = () => void;
		export { QueryErrorResetFunction }
		export { QueryErrorResetFunction as QueryErrorResetFunction_alias_1 }

		export { QueryFilters }

		export { QueryFunction }

		export { QueryFunctionContext }

		export { QueryKey }

		export { QueryKeyHashFunction }

		export { QueryMeta }

		export { QueryObserver }

		export { QueryObserverBaseResult }

		export { QueryObserverLoadingErrorResult }

		export { QueryObserverLoadingResult }

		export { QueryObserverOptions }

		export { QueryObserverPendingResult }

		export { QueryObserverPlaceholderResult }

		export { QueryObserverRefetchErrorResult }

		export { QueryObserverResult }

		export { QueryObserverSuccessResult }

		export { QueryOptions }

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};
		export { queryOptions }
		export { queryOptions as queryOptions_alias_1 }

		export { QueryPersister }

		export { QueryState }

		export { QueryStatus }

		export { RefetchOptions }

		export { RefetchQueryFilters }

		export { Register }

		export { replaceEqualDeep }

		export { ResetOptions }

		export { ResultOptions }

		export { SetDataOptions }

		export declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;

		export { shouldThrowError }

		export { SkipToken }

		export { skipToken }

		declare type SkipTokenForUseQueries = symbol;

		declare type SkipTokenForUseQueries_2 = symbol;

		export { StaleTime }

		export { StaleTimeFunction }

		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryOptions<Head>
		], [
		...TDepth,
		1
		]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		export { SuspenseQueriesOptions }
		export { SuspenseQueriesOptions as SuspenseQueriesOptions_alias_1 }

		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		declare type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseSuspenseQueryResult<T[K]>;
		};
		export { SuspenseQueriesResults }
		export { SuspenseQueriesResults as SuspenseQueriesResults_alias_1 }

		export { ThrowOnError }

		export { TimeoutCallback }

		export { timeoutManager }

		export { TimeoutProvider }

		declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		export { UndefinedInitialDataInfiniteOptions }
		export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }

		declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		export { UndefinedInitialDataOptions }
		export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }

		export { UnsetMarker }

		export { unsetMarker }

		declare type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenInfiniteOptions }
		export { UnusedSkipTokenInfiniteOptions as UnusedSkipTokenInfiniteOptions_alias_1 }

		declare type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenOptions }
		export { UnusedSkipTokenOptions as UnusedSkipTokenOptions_alias_1 }

		export { Updater }

		declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		export { UseBaseMutationResult }
		export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }

		export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;

		declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseBaseQueryOptions }
		export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }

		declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		export { UseBaseQueryResult }
		export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }

		export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		export { useInfiniteQuery }
		export { useInfiniteQuery as useInfiniteQuery_alias_1 }

		declare interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseInfiniteQueryOptions }
		export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }

		declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		export { UseInfiniteQueryResult }
		export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }

		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		export { useIsFetching }
		export { useIsFetching as useIsFetching_alias_1 }

		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		export { useIsMutating }
		export { useIsMutating as useIsMutating_alias_1 }

		declare const useIsRestoring: () => boolean;
		export { useIsRestoring }
		export { useIsRestoring as useIsRestoring_alias_1 }

		declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutateAsyncFunction }
		export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }

		declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		export { UseMutateFunction }
		export { UseMutateFunction as UseMutateFunction_alias_1 }

		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { useMutation }
		export { useMutation as useMutation_alias_1 }

		declare interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
		}
		export { UseMutationOptions }
		export { UseMutationOptions as UseMutationOptions_alias_1 }

		declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutationResult }
		export { UseMutationResult as UseMutationResult_alias_1 }

		declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult>, queryClient?: QueryClient): Array<TResult>;
		export { useMutationState }
		export { useMutationState as useMutationState_alias_1 }

		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		export { usePrefetchInfiniteQuery }
		export { usePrefetchInfiniteQuery as usePrefetchInfiniteQuery_alias_1 }

		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): void;
		export { usePrefetchQuery }
		export { usePrefetchQuery as usePrefetchQuery_alias_1 }

		declare interface UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> {
		queryFn?: Exclude<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UsePrefetchQueryOptions }
		export { UsePrefetchQueryOptions as UsePrefetchQueryOptions_alias_1 }

		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
		}];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useQueries }
		export { useQueries as useQueries_alias_1 }

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
		export { useQuery }
		export { useQuery as useQuery_alias_1 }

		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		export { useQueryClient }
		export { useQueryClient as useQueryClient_alias_1 }

		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		export { useQueryErrorResetBoundary }
		export { useQueryErrorResetBoundary as useQueryErrorResetBoundary_alias_1 }

		declare interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
		}
		export { UseQueryOptions }
		export { UseQueryOptions as UseQueryOptions_alias_1 }

		declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};

		declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		export { UseQueryResult }
		export { UseQueryResult as UseQueryResult_alias_1 }

		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		export { useSuspenseInfiniteQuery }
		export { useSuspenseInfiniteQuery as useSuspenseInfiniteQuery_alias_1 }

		declare interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		export { UseSuspenseInfiniteQueryOptions }
		export { UseSuspenseInfiniteQueryOptions as UseSuspenseInfiniteQueryOptions_alias_1 }

		declare type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseInfiniteQueryResult }
		export { UseSuspenseInfiniteQueryResult as UseSuspenseInfiniteQueryResult_alias_1 }

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseSuspenseQueryOptions<T[K]>;
		}];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useSuspenseQueries }
		export { useSuspenseQueries as useSuspenseQueries_alias_1 }

		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		export { useSuspenseQuery }
		export { useSuspenseQuery as useSuspenseQuery_alias_1 }

		declare interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UseSuspenseQueryOptions }
		export { UseSuspenseQueryOptions as UseSuspenseQueryOptions_alias_1 }

		declare type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseQueryResult }
		export { UseSuspenseQueryResult as UseSuspenseQueryResult_alias_1 }

		export declare const willFetch: (result: QueryObserverResult<any, any>, isRestoring: boolean) => boolean;

		export { WithRequired }

		export { }

-947

build/legacy/_tsup-dts-rollup.d.ts

		import { AnyDataTag } from '@tanstack/query-core';
		import { CancelledError } from '@tanstack/query-core';
		import { CancelOptions } from '@tanstack/query-core';
		import { DataTag } from '@tanstack/query-core';
		import { dataTagErrorSymbol } from '@tanstack/query-core';
		import { dataTagSymbol } from '@tanstack/query-core';
		import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultError } from '@tanstack/query-core';
		import { DefaultOptions } from '@tanstack/query-core';
		import { defaultScheduler } from '@tanstack/query-core';
		import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
		import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
		import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
		import { DefinedQueryObserverResult } from '@tanstack/query-core';
		import { dehydrate } from '@tanstack/query-core';
		import { DehydratedState } from '@tanstack/query-core';
		import { DehydrateOptions } from '@tanstack/query-core';
		import { DistributiveOmit } from '@tanstack/query-core';
		import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
		import { EnsureQueryDataOptions } from '@tanstack/query-core';
		import { environmentManager } from '@tanstack/query-core';
		import { experimental_streamedQuery } from '@tanstack/query-core';
		import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
		import { FetchNextPageOptions } from '@tanstack/query-core';
		import { FetchPreviousPageOptions } from '@tanstack/query-core';
		import { FetchQueryOptions } from '@tanstack/query-core';
		import { FetchStatus } from '@tanstack/query-core';
		import { focusManager } from '@tanstack/query-core';
		import { GetNextPageParamFunction } from '@tanstack/query-core';
		import { GetPreviousPageParamFunction } from '@tanstack/query-core';
		import { hashKey } from '@tanstack/query-core';
		import { hydrate } from '@tanstack/query-core';
		import { HydrateOptions } from '@tanstack/query-core';
		import { InferDataFromTag } from '@tanstack/query-core';
		import { InferErrorFromTag } from '@tanstack/query-core';
		import { InfiniteData } from '@tanstack/query-core';
		import { InfiniteQueryObserver } from '@tanstack/query-core';
		import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
		import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
		import { InitialDataFunction } from '@tanstack/query-core';
		import { InitialPageParam } from '@tanstack/query-core';
		import { InvalidateOptions } from '@tanstack/query-core';
		import { InvalidateQueryFilters } from '@tanstack/query-core';
		import { isCancelledError } from '@tanstack/query-core';
		import { isServer } from '@tanstack/query-core';
		import { JSX } from 'react/jsx-runtime';
		import { keepPreviousData } from '@tanstack/query-core';
		import { ManagedTimerId } from '@tanstack/query-core';
		import { matchMutation } from '@tanstack/query-core';
		import { matchQuery } from '@tanstack/query-core';
		import { MutateFunction } from '@tanstack/query-core';
		import { MutateOptions } from '@tanstack/query-core';
		import { Mutation } from '@tanstack/query-core';
		import { MutationCache } from '@tanstack/query-core';
		import { MutationCacheNotifyEvent } from '@tanstack/query-core';
		import { MutationFilters } from '@tanstack/query-core';
		import { MutationFunction } from '@tanstack/query-core';
		import { MutationFunctionContext } from '@tanstack/query-core';
		import { MutationKey } from '@tanstack/query-core';
		import { MutationMeta } from '@tanstack/query-core';
		import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
		import { MutationObserverBaseResult } from '@tanstack/query-core';
		import { MutationObserverErrorResult } from '@tanstack/query-core';
		import { MutationObserverIdleResult } from '@tanstack/query-core';
		import { MutationObserverLoadingResult } from '@tanstack/query-core';
		import { MutationObserverOptions } from '@tanstack/query-core';
		import { MutationObserverResult } from '@tanstack/query-core';
		import { MutationObserverSuccessResult } from '@tanstack/query-core';
		import { MutationOptions } from '@tanstack/query-core';
		import { MutationScope } from '@tanstack/query-core';
		import { MutationState } from '@tanstack/query-core';
		import { MutationStatus } from '@tanstack/query-core';
		import { NetworkMode } from '@tanstack/query-core';
		import { NonUndefinedGuard } from '@tanstack/query-core';
		import { noop } from '@tanstack/query-core';
		import { NotifyEvent } from '@tanstack/query-core';
		import { NotifyEventType } from '@tanstack/query-core';
		import { notifyManager } from '@tanstack/query-core';
		import { NotifyOnChangeProps } from '@tanstack/query-core';
		import { OmitKeyof } from '@tanstack/query-core';
		import { onlineManager } from '@tanstack/query-core';
		import { Override } from '@tanstack/query-core';
		import { partialMatchKey } from '@tanstack/query-core';
		import { PlaceholderDataFunction } from '@tanstack/query-core';
		import { QueriesObserver } from '@tanstack/query-core';
		import { QueriesObserverOptions } from '@tanstack/query-core';
		import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
		import { Query } from '@tanstack/query-core';
		import { QueryBooleanOption } from '@tanstack/query-core';
		import { QueryCache } from '@tanstack/query-core';
		import { QueryCacheNotifyEvent } from '@tanstack/query-core';
		import { QueryClient } from '@tanstack/query-core';
		import { QueryClientConfig } from '@tanstack/query-core';
		import { QueryFilters } from '@tanstack/query-core';
		import { QueryFunction } from '@tanstack/query-core';
		import { QueryFunctionContext } from '@tanstack/query-core';
		import { QueryKey } from '@tanstack/query-core';
		import { QueryKeyHashFunction } from '@tanstack/query-core';
		import { QueryMeta } from '@tanstack/query-core';
		import { QueryObserver } from '@tanstack/query-core';
		import { QueryObserverBaseResult } from '@tanstack/query-core';
		import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { QueryObserverLoadingResult } from '@tanstack/query-core';
		import { QueryObserverOptions } from '@tanstack/query-core';
		import { QueryObserverPendingResult } from '@tanstack/query-core';
		import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { QueryObserverResult } from '@tanstack/query-core';
		import { QueryObserverSuccessResult } from '@tanstack/query-core';
		import { QueryOptions } from '@tanstack/query-core';
		import { QueryPersister } from '@tanstack/query-core';
		import { QueryState } from '@tanstack/query-core';
		import { QueryStatus } from '@tanstack/query-core';
		import * as React_2 from 'react';
		import { RefetchOptions } from '@tanstack/query-core';
		import { RefetchQueryFilters } from '@tanstack/query-core';
		import { Register } from '@tanstack/query-core';
		import { replaceEqualDeep } from '@tanstack/query-core';
		import { ResetOptions } from '@tanstack/query-core';
		import { ResultOptions } from '@tanstack/query-core';
		import { SetDataOptions } from '@tanstack/query-core';
		import { shouldThrowError } from '@tanstack/query-core';
		import { SkipToken } from '@tanstack/query-core';
		import { skipToken } from '@tanstack/query-core';
		import { StaleTime } from '@tanstack/query-core';
		import { StaleTimeFunction } from '@tanstack/query-core';
		import { ThrowOnError } from '@tanstack/query-core';
		import { TimeoutCallback } from '@tanstack/query-core';
		import { timeoutManager } from '@tanstack/query-core';
		import { TimeoutProvider } from '@tanstack/query-core';
		import { UnsetMarker } from '@tanstack/query-core';
		import { unsetMarker } from '@tanstack/query-core';
		import { Updater } from '@tanstack/query-core';
		import { WithRequired } from '@tanstack/query-core';

		export { AnyDataTag }

		declare type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		export { AnyUseBaseQueryOptions }
		export { AnyUseBaseQueryOptions as AnyUseBaseQueryOptions_alias_1 }

		declare type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseInfiniteQueryOptions }
		export { AnyUseInfiniteQueryOptions as AnyUseInfiniteQueryOptions_alias_1 }

		declare type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		export { AnyUseMutationOptions }
		export { AnyUseMutationOptions as AnyUseMutationOptions_alias_1 }

		declare type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		export { AnyUseQueryOptions }
		export { AnyUseQueryOptions as AnyUseQueryOptions_alias_1 }

		declare type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseSuspenseInfiniteQueryOptions }
		export { AnyUseSuspenseInfiniteQueryOptions as AnyUseSuspenseInfiniteQueryOptions_alias_1 }

		declare type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		export { AnyUseSuspenseQueryOptions }
		export { AnyUseSuspenseQueryOptions as AnyUseSuspenseQueryOptions_alias_1 }

		export { CancelledError }

		export { CancelOptions }

		export { DataTag }

		export { dataTagErrorSymbol }

		export { dataTagSymbol }

		export { DefaultedInfiniteQueryObserverOptions }

		export { DefaultedQueryObserverOptions }

		export { DefaultError }

		export { DefaultOptions }

		export { defaultScheduler }

		export { defaultShouldDehydrateMutation }

		export { defaultShouldDehydrateQuery }

		export declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;

		export { DefinedInfiniteQueryObserverResult }

		declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		export { DefinedInitialDataInfiniteOptions }
		export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }

		declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		export { DefinedInitialDataOptions }
		export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }

		export { DefinedQueryObserverResult }

		declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		export { DefinedUseInfiniteQueryResult }
		export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }

		declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		export { DefinedUseQueryResult }
		export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }

		export { dehydrate }

		export { DehydratedState }

		export { DehydrateOptions }

		export { DistributiveOmit }

		export { EnsureInfiniteQueryDataOptions }

		export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;

		export { EnsureQueryDataOptions }

		export declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;

		export { environmentManager }

		export { experimental_streamedQuery }

		export { FetchInfiniteQueryOptions }

		export { FetchNextPageOptions }

		export declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;

		export { FetchPreviousPageOptions }

		export { FetchQueryOptions }

		export { FetchStatus }

		export { focusManager }

		declare type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;

		export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense, }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;

		export { GetNextPageParamFunction }

		export { GetPreviousPageParamFunction }

		declare type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;

		declare type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;

		declare type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;

		declare type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;

		export { hashKey }

		export { hydrate }

		export { HydrateOptions }

		declare const HydrationBoundary: ({ children, options, state, queryClient, }: HydrationBoundaryProps) => React_2.ReactElement;
		export { HydrationBoundary }
		export { HydrationBoundary as HydrationBoundary_alias_1 }

		declare interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React_2.ReactNode;
		queryClient?: QueryClient;
		}
		export { HydrationBoundaryProps }
		export { HydrationBoundaryProps as HydrationBoundaryProps_alias_1 }

		export { InferDataFromTag }

		export { InferErrorFromTag }

		export { InfiniteData }

		export { InfiniteQueryObserver }

		export { InfiniteQueryObserverBaseResult }

		export { InfiniteQueryObserverLoadingErrorResult }

		export { InfiniteQueryObserverLoadingResult }

		export { InfiniteQueryObserverOptions }

		export { InfiniteQueryObserverPendingResult }

		export { InfiniteQueryObserverPlaceholderResult }

		export { InfiniteQueryObserverRefetchErrorResult }

		export { InfiniteQueryObserverResult }

		export { InfiniteQueryObserverSuccessResult }

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};
		export { infiniteQueryOptions }
		export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }

		export { InfiniteQueryPageParamsOptions }

		export { InitialDataFunction }

		export { InitialPageParam }

		export { InvalidateOptions }

		export { InvalidateQueryFilters }

		export { isCancelledError }

		declare const IsRestoringProvider: React_2.Provider<boolean>;
		export { IsRestoringProvider }
		export { IsRestoringProvider as IsRestoringProvider_alias_1 }

		export { isServer }

		export { keepPreviousData }

		export { ManagedTimerId }

		export { matchMutation }

		export { matchQuery }

		declare type MAXIMUM_DEPTH = 20;

		declare type MAXIMUM_DEPTH_2 = 20;

		export { MutateFunction }

		export { MutateOptions }

		export { Mutation }

		export { MutationCache }

		export { MutationCacheNotifyEvent }

		export { MutationFilters }

		export { MutationFunction }

		export { MutationFunctionContext }

		export { MutationKey }

		export { MutationMeta }

		export { MutationObserver_2 as MutationObserver }

		export { MutationObserverBaseResult }

		export { MutationObserverErrorResult }

		export { MutationObserverIdleResult }

		export { MutationObserverLoadingResult }

		export { MutationObserverOptions }

		export { MutationObserverResult }

		export { MutationObserverSuccessResult }

		export { MutationOptions }

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		export { mutationOptions }
		export { mutationOptions as mutationOptions_alias_1 }

		export { MutationScope }

		export { MutationState }

		declare type MutationStateOptions<TResult = MutationState> = {
		filters?: MutationFilters;
		select?: (mutation: Mutation) => TResult;
		};

		export { MutationStatus }

		export { NetworkMode }

		export { NonUndefinedGuard }

		export { noop }

		export { NotifyEvent }

		export { NotifyEventType }

		export { notifyManager }

		export { NotifyOnChangeProps }

		export { OmitKeyof }

		export { onlineManager }

		export { Override }

		export { partialMatchKey }

		export { PlaceholderDataFunction }

		export { QueriesObserver }

		export { QueriesObserverOptions }

		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseQueryOptionsForUseQueries<Head>
		], [
		...TDepth,
		1
		]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		export { QueriesOptions }
		export { QueriesOptions as QueriesOptions_alias_1 }

		export { QueriesPlaceholderDataFunction }

		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		declare type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseQueryResult<T[K]>;
		};
		export { QueriesResults }
		export { QueriesResults as QueriesResults_alias_1 }

		export { Query }

		export { QueryBooleanOption }

		export { QueryCache }

		export { QueryCacheNotifyEvent }

		export { QueryClient }

		export { QueryClientConfig }

		declare const QueryClientContext: React_2.Context<QueryClient \| undefined>;
		export { QueryClientContext }
		export { QueryClientContext as QueryClientContext_alias_1 }

		declare const QueryClientProvider: ({ client, children, }: QueryClientProviderProps) => React_2.JSX.Element;
		export { QueryClientProvider }
		export { QueryClientProvider as QueryClientProvider_alias_1 }

		declare type QueryClientProviderProps = {
		client: QueryClient;
		children?: React_2.ReactNode;
		};
		export { QueryClientProviderProps }
		export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }

		declare type QueryErrorClearResetFunction = () => void;
		export { QueryErrorClearResetFunction }
		export { QueryErrorClearResetFunction as QueryErrorClearResetFunction_alias_1 }

		declare type QueryErrorIsResetFunction = () => boolean;
		export { QueryErrorIsResetFunction }
		export { QueryErrorIsResetFunction as QueryErrorIsResetFunction_alias_1 }

		declare const QueryErrorResetBoundary: ({ children, }: QueryErrorResetBoundaryProps) => JSX.Element;
		export { QueryErrorResetBoundary }
		export { QueryErrorResetBoundary as QueryErrorResetBoundary_alias_1 }

		declare type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React_2.ReactNode;
		export { QueryErrorResetBoundaryFunction }
		export { QueryErrorResetBoundaryFunction as QueryErrorResetBoundaryFunction_alias_1 }

		declare interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React_2.ReactNode;
		}
		export { QueryErrorResetBoundaryProps }
		export { QueryErrorResetBoundaryProps as QueryErrorResetBoundaryProps_alias_1 }

		export declare interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}

		declare type QueryErrorResetFunction = () => void;
		export { QueryErrorResetFunction }
		export { QueryErrorResetFunction as QueryErrorResetFunction_alias_1 }

		export { QueryFilters }

		export { QueryFunction }

		export { QueryFunctionContext }

		export { QueryKey }

		export { QueryKeyHashFunction }

		export { QueryMeta }

		export { QueryObserver }

		export { QueryObserverBaseResult }

		export { QueryObserverLoadingErrorResult }

		export { QueryObserverLoadingResult }

		export { QueryObserverOptions }

		export { QueryObserverPendingResult }

		export { QueryObserverPlaceholderResult }

		export { QueryObserverRefetchErrorResult }

		export { QueryObserverResult }

		export { QueryObserverSuccessResult }

		export { QueryOptions }

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};
		export { queryOptions }
		export { queryOptions as queryOptions_alias_1 }

		export { QueryPersister }

		export { QueryState }

		export { QueryStatus }

		export { RefetchOptions }

		export { RefetchQueryFilters }

		export { Register }

		export { replaceEqualDeep }

		export { ResetOptions }

		export { ResultOptions }

		export { SetDataOptions }

		export declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;

		export { shouldThrowError }

		export { SkipToken }

		export { skipToken }

		declare type SkipTokenForUseQueries = symbol;

		declare type SkipTokenForUseQueries_2 = symbol;

		export { StaleTime }

		export { StaleTimeFunction }

		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryOptions<Head>
		], [
		...TDepth,
		1
		]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		export { SuspenseQueriesOptions }
		export { SuspenseQueriesOptions as SuspenseQueriesOptions_alias_1 }

		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		declare type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseSuspenseQueryResult<T[K]>;
		};
		export { SuspenseQueriesResults }
		export { SuspenseQueriesResults as SuspenseQueriesResults_alias_1 }

		export { ThrowOnError }

		export { TimeoutCallback }

		export { timeoutManager }

		export { TimeoutProvider }

		declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		export { UndefinedInitialDataInfiniteOptions }
		export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }

		declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		export { UndefinedInitialDataOptions }
		export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }

		export { UnsetMarker }

		export { unsetMarker }

		declare type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenInfiniteOptions }
		export { UnusedSkipTokenInfiniteOptions as UnusedSkipTokenInfiniteOptions_alias_1 }

		declare type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenOptions }
		export { UnusedSkipTokenOptions as UnusedSkipTokenOptions_alias_1 }

		export { Updater }

		declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		export { UseBaseMutationResult }
		export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }

		export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;

		declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseBaseQueryOptions }
		export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }

		declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		export { UseBaseQueryResult }
		export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }

		export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		export { useInfiniteQuery }
		export { useInfiniteQuery as useInfiniteQuery_alias_1 }

		declare interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseInfiniteQueryOptions }
		export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }

		declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		export { UseInfiniteQueryResult }
		export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }

		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		export { useIsFetching }
		export { useIsFetching as useIsFetching_alias_1 }

		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		export { useIsMutating }
		export { useIsMutating as useIsMutating_alias_1 }

		declare const useIsRestoring: () => boolean;
		export { useIsRestoring }
		export { useIsRestoring as useIsRestoring_alias_1 }

		declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutateAsyncFunction }
		export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }

		declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		export { UseMutateFunction }
		export { UseMutateFunction as UseMutateFunction_alias_1 }

		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { useMutation }
		export { useMutation as useMutation_alias_1 }

		declare interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
		}
		export { UseMutationOptions }
		export { UseMutationOptions as UseMutationOptions_alias_1 }

		declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutationResult }
		export { UseMutationResult as UseMutationResult_alias_1 }

		declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult>, queryClient?: QueryClient): Array<TResult>;
		export { useMutationState }
		export { useMutationState as useMutationState_alias_1 }

		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		export { usePrefetchInfiniteQuery }
		export { usePrefetchInfiniteQuery as usePrefetchInfiniteQuery_alias_1 }

		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): void;
		export { usePrefetchQuery }
		export { usePrefetchQuery as usePrefetchQuery_alias_1 }

		declare interface UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> {
		queryFn?: Exclude<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UsePrefetchQueryOptions }
		export { UsePrefetchQueryOptions as UsePrefetchQueryOptions_alias_1 }

		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
		}];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useQueries }
		export { useQueries as useQueries_alias_1 }

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
		export { useQuery }
		export { useQuery as useQuery_alias_1 }

		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		export { useQueryClient }
		export { useQueryClient as useQueryClient_alias_1 }

		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		export { useQueryErrorResetBoundary }
		export { useQueryErrorResetBoundary as useQueryErrorResetBoundary_alias_1 }

		declare interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
		}
		export { UseQueryOptions }
		export { UseQueryOptions as UseQueryOptions_alias_1 }

		declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};

		declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		export { UseQueryResult }
		export { UseQueryResult as UseQueryResult_alias_1 }

		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		export { useSuspenseInfiniteQuery }
		export { useSuspenseInfiniteQuery as useSuspenseInfiniteQuery_alias_1 }

		declare interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		export { UseSuspenseInfiniteQueryOptions }
		export { UseSuspenseInfiniteQueryOptions as UseSuspenseInfiniteQueryOptions_alias_1 }

		declare type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseInfiniteQueryResult }
		export { UseSuspenseInfiniteQueryResult as UseSuspenseInfiniteQueryResult_alias_1 }

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseSuspenseQueryOptions<T[K]>;
		}];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useSuspenseQueries }
		export { useSuspenseQueries as useSuspenseQueries_alias_1 }

		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		export { useSuspenseQuery }
		export { useSuspenseQuery as useSuspenseQuery_alias_1 }

		declare interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UseSuspenseQueryOptions }
		export { UseSuspenseQueryOptions as UseSuspenseQueryOptions_alias_1 }

		declare type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseQueryResult }
		export { UseSuspenseQueryResult as UseSuspenseQueryResult_alias_1 }

		export declare const willFetch: (result: QueryObserverResult<any, any>, isRestoring: boolean) => boolean;

		export { WithRequired }

		export { }

-947

build/modern/_tsup-dts-rollup.d.cts

		import { AnyDataTag } from '@tanstack/query-core';
		import { CancelledError } from '@tanstack/query-core';
		import { CancelOptions } from '@tanstack/query-core';
		import { DataTag } from '@tanstack/query-core';
		import { dataTagErrorSymbol } from '@tanstack/query-core';
		import { dataTagSymbol } from '@tanstack/query-core';
		import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultError } from '@tanstack/query-core';
		import { DefaultOptions } from '@tanstack/query-core';
		import { defaultScheduler } from '@tanstack/query-core';
		import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
		import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
		import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
		import { DefinedQueryObserverResult } from '@tanstack/query-core';
		import { dehydrate } from '@tanstack/query-core';
		import { DehydratedState } from '@tanstack/query-core';
		import { DehydrateOptions } from '@tanstack/query-core';
		import { DistributiveOmit } from '@tanstack/query-core';
		import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
		import { EnsureQueryDataOptions } from '@tanstack/query-core';
		import { environmentManager } from '@tanstack/query-core';
		import { experimental_streamedQuery } from '@tanstack/query-core';
		import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
		import { FetchNextPageOptions } from '@tanstack/query-core';
		import { FetchPreviousPageOptions } from '@tanstack/query-core';
		import { FetchQueryOptions } from '@tanstack/query-core';
		import { FetchStatus } from '@tanstack/query-core';
		import { focusManager } from '@tanstack/query-core';
		import { GetNextPageParamFunction } from '@tanstack/query-core';
		import { GetPreviousPageParamFunction } from '@tanstack/query-core';
		import { hashKey } from '@tanstack/query-core';
		import { hydrate } from '@tanstack/query-core';
		import { HydrateOptions } from '@tanstack/query-core';
		import { InferDataFromTag } from '@tanstack/query-core';
		import { InferErrorFromTag } from '@tanstack/query-core';
		import { InfiniteData } from '@tanstack/query-core';
		import { InfiniteQueryObserver } from '@tanstack/query-core';
		import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
		import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
		import { InitialDataFunction } from '@tanstack/query-core';
		import { InitialPageParam } from '@tanstack/query-core';
		import { InvalidateOptions } from '@tanstack/query-core';
		import { InvalidateQueryFilters } from '@tanstack/query-core';
		import { isCancelledError } from '@tanstack/query-core';
		import { isServer } from '@tanstack/query-core';
		import { JSX } from 'react/jsx-runtime';
		import { keepPreviousData } from '@tanstack/query-core';
		import { ManagedTimerId } from '@tanstack/query-core';
		import { matchMutation } from '@tanstack/query-core';
		import { matchQuery } from '@tanstack/query-core';
		import { MutateFunction } from '@tanstack/query-core';
		import { MutateOptions } from '@tanstack/query-core';
		import { Mutation } from '@tanstack/query-core';
		import { MutationCache } from '@tanstack/query-core';
		import { MutationCacheNotifyEvent } from '@tanstack/query-core';
		import { MutationFilters } from '@tanstack/query-core';
		import { MutationFunction } from '@tanstack/query-core';
		import { MutationFunctionContext } from '@tanstack/query-core';
		import { MutationKey } from '@tanstack/query-core';
		import { MutationMeta } from '@tanstack/query-core';
		import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
		import { MutationObserverBaseResult } from '@tanstack/query-core';
		import { MutationObserverErrorResult } from '@tanstack/query-core';
		import { MutationObserverIdleResult } from '@tanstack/query-core';
		import { MutationObserverLoadingResult } from '@tanstack/query-core';
		import { MutationObserverOptions } from '@tanstack/query-core';
		import { MutationObserverResult } from '@tanstack/query-core';
		import { MutationObserverSuccessResult } from '@tanstack/query-core';
		import { MutationOptions } from '@tanstack/query-core';
		import { MutationScope } from '@tanstack/query-core';
		import { MutationState } from '@tanstack/query-core';
		import { MutationStatus } from '@tanstack/query-core';
		import { NetworkMode } from '@tanstack/query-core';
		import { NonUndefinedGuard } from '@tanstack/query-core';
		import { noop } from '@tanstack/query-core';
		import { NotifyEvent } from '@tanstack/query-core';
		import { NotifyEventType } from '@tanstack/query-core';
		import { notifyManager } from '@tanstack/query-core';
		import { NotifyOnChangeProps } from '@tanstack/query-core';
		import { OmitKeyof } from '@tanstack/query-core';
		import { onlineManager } from '@tanstack/query-core';
		import { Override } from '@tanstack/query-core';
		import { partialMatchKey } from '@tanstack/query-core';
		import { PlaceholderDataFunction } from '@tanstack/query-core';
		import { QueriesObserver } from '@tanstack/query-core';
		import { QueriesObserverOptions } from '@tanstack/query-core';
		import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
		import { Query } from '@tanstack/query-core';
		import { QueryBooleanOption } from '@tanstack/query-core';
		import { QueryCache } from '@tanstack/query-core';
		import { QueryCacheNotifyEvent } from '@tanstack/query-core';
		import { QueryClient } from '@tanstack/query-core';
		import { QueryClientConfig } from '@tanstack/query-core';
		import { QueryFilters } from '@tanstack/query-core';
		import { QueryFunction } from '@tanstack/query-core';
		import { QueryFunctionContext } from '@tanstack/query-core';
		import { QueryKey } from '@tanstack/query-core';
		import { QueryKeyHashFunction } from '@tanstack/query-core';
		import { QueryMeta } from '@tanstack/query-core';
		import { QueryObserver } from '@tanstack/query-core';
		import { QueryObserverBaseResult } from '@tanstack/query-core';
		import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { QueryObserverLoadingResult } from '@tanstack/query-core';
		import { QueryObserverOptions } from '@tanstack/query-core';
		import { QueryObserverPendingResult } from '@tanstack/query-core';
		import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { QueryObserverResult } from '@tanstack/query-core';
		import { QueryObserverSuccessResult } from '@tanstack/query-core';
		import { QueryOptions } from '@tanstack/query-core';
		import { QueryPersister } from '@tanstack/query-core';
		import { QueryState } from '@tanstack/query-core';
		import { QueryStatus } from '@tanstack/query-core';
		import * as React_2 from 'react';
		import { RefetchOptions } from '@tanstack/query-core';
		import { RefetchQueryFilters } from '@tanstack/query-core';
		import { Register } from '@tanstack/query-core';
		import { replaceEqualDeep } from '@tanstack/query-core';
		import { ResetOptions } from '@tanstack/query-core';
		import { ResultOptions } from '@tanstack/query-core';
		import { SetDataOptions } from '@tanstack/query-core';
		import { shouldThrowError } from '@tanstack/query-core';
		import { SkipToken } from '@tanstack/query-core';
		import { skipToken } from '@tanstack/query-core';
		import { StaleTime } from '@tanstack/query-core';
		import { StaleTimeFunction } from '@tanstack/query-core';
		import { ThrowOnError } from '@tanstack/query-core';
		import { TimeoutCallback } from '@tanstack/query-core';
		import { timeoutManager } from '@tanstack/query-core';
		import { TimeoutProvider } from '@tanstack/query-core';
		import { UnsetMarker } from '@tanstack/query-core';
		import { unsetMarker } from '@tanstack/query-core';
		import { Updater } from '@tanstack/query-core';
		import { WithRequired } from '@tanstack/query-core';

		export { AnyDataTag }

		declare type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		export { AnyUseBaseQueryOptions }
		export { AnyUseBaseQueryOptions as AnyUseBaseQueryOptions_alias_1 }

		declare type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseInfiniteQueryOptions }
		export { AnyUseInfiniteQueryOptions as AnyUseInfiniteQueryOptions_alias_1 }

		declare type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		export { AnyUseMutationOptions }
		export { AnyUseMutationOptions as AnyUseMutationOptions_alias_1 }

		declare type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		export { AnyUseQueryOptions }
		export { AnyUseQueryOptions as AnyUseQueryOptions_alias_1 }

		declare type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseSuspenseInfiniteQueryOptions }
		export { AnyUseSuspenseInfiniteQueryOptions as AnyUseSuspenseInfiniteQueryOptions_alias_1 }

		declare type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		export { AnyUseSuspenseQueryOptions }
		export { AnyUseSuspenseQueryOptions as AnyUseSuspenseQueryOptions_alias_1 }

		export { CancelledError }

		export { CancelOptions }

		export { DataTag }

		export { dataTagErrorSymbol }

		export { dataTagSymbol }

		export { DefaultedInfiniteQueryObserverOptions }

		export { DefaultedQueryObserverOptions }

		export { DefaultError }

		export { DefaultOptions }

		export { defaultScheduler }

		export { defaultShouldDehydrateMutation }

		export { defaultShouldDehydrateQuery }

		export declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;

		export { DefinedInfiniteQueryObserverResult }

		declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		export { DefinedInitialDataInfiniteOptions }
		export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }

		declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		export { DefinedInitialDataOptions }
		export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }

		export { DefinedQueryObserverResult }

		declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		export { DefinedUseInfiniteQueryResult }
		export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }

		declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		export { DefinedUseQueryResult }
		export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }

		export { dehydrate }

		export { DehydratedState }

		export { DehydrateOptions }

		export { DistributiveOmit }

		export { EnsureInfiniteQueryDataOptions }

		export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;

		export { EnsureQueryDataOptions }

		export declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;

		export { environmentManager }

		export { experimental_streamedQuery }

		export { FetchInfiniteQueryOptions }

		export { FetchNextPageOptions }

		export declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;

		export { FetchPreviousPageOptions }

		export { FetchQueryOptions }

		export { FetchStatus }

		export { focusManager }

		declare type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;

		export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense, }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;

		export { GetNextPageParamFunction }

		export { GetPreviousPageParamFunction }

		declare type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;

		declare type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;

		declare type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;

		declare type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;

		export { hashKey }

		export { hydrate }

		export { HydrateOptions }

		declare const HydrationBoundary: ({ children, options, state, queryClient, }: HydrationBoundaryProps) => React_2.ReactElement;
		export { HydrationBoundary }
		export { HydrationBoundary as HydrationBoundary_alias_1 }

		declare interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React_2.ReactNode;
		queryClient?: QueryClient;
		}
		export { HydrationBoundaryProps }
		export { HydrationBoundaryProps as HydrationBoundaryProps_alias_1 }

		export { InferDataFromTag }

		export { InferErrorFromTag }

		export { InfiniteData }

		export { InfiniteQueryObserver }

		export { InfiniteQueryObserverBaseResult }

		export { InfiniteQueryObserverLoadingErrorResult }

		export { InfiniteQueryObserverLoadingResult }

		export { InfiniteQueryObserverOptions }

		export { InfiniteQueryObserverPendingResult }

		export { InfiniteQueryObserverPlaceholderResult }

		export { InfiniteQueryObserverRefetchErrorResult }

		export { InfiniteQueryObserverResult }

		export { InfiniteQueryObserverSuccessResult }

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};
		export { infiniteQueryOptions }
		export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }

		export { InfiniteQueryPageParamsOptions }

		export { InitialDataFunction }

		export { InitialPageParam }

		export { InvalidateOptions }

		export { InvalidateQueryFilters }

		export { isCancelledError }

		declare const IsRestoringProvider: React_2.Provider<boolean>;
		export { IsRestoringProvider }
		export { IsRestoringProvider as IsRestoringProvider_alias_1 }

		export { isServer }

		export { keepPreviousData }

		export { ManagedTimerId }

		export { matchMutation }

		export { matchQuery }

		declare type MAXIMUM_DEPTH = 20;

		declare type MAXIMUM_DEPTH_2 = 20;

		export { MutateFunction }

		export { MutateOptions }

		export { Mutation }

		export { MutationCache }

		export { MutationCacheNotifyEvent }

		export { MutationFilters }

		export { MutationFunction }

		export { MutationFunctionContext }

		export { MutationKey }

		export { MutationMeta }

		export { MutationObserver_2 as MutationObserver }

		export { MutationObserverBaseResult }

		export { MutationObserverErrorResult }

		export { MutationObserverIdleResult }

		export { MutationObserverLoadingResult }

		export { MutationObserverOptions }

		export { MutationObserverResult }

		export { MutationObserverSuccessResult }

		export { MutationOptions }

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		export { mutationOptions }
		export { mutationOptions as mutationOptions_alias_1 }

		export { MutationScope }

		export { MutationState }

		declare type MutationStateOptions<TResult = MutationState> = {
		filters?: MutationFilters;
		select?: (mutation: Mutation) => TResult;
		};

		export { MutationStatus }

		export { NetworkMode }

		export { NonUndefinedGuard }

		export { noop }

		export { NotifyEvent }

		export { NotifyEventType }

		export { notifyManager }

		export { NotifyOnChangeProps }

		export { OmitKeyof }

		export { onlineManager }

		export { Override }

		export { partialMatchKey }

		export { PlaceholderDataFunction }

		export { QueriesObserver }

		export { QueriesObserverOptions }

		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseQueryOptionsForUseQueries<Head>
		], [
		...TDepth,
		1
		]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		export { QueriesOptions }
		export { QueriesOptions as QueriesOptions_alias_1 }

		export { QueriesPlaceholderDataFunction }

		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		declare type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseQueryResult<T[K]>;
		};
		export { QueriesResults }
		export { QueriesResults as QueriesResults_alias_1 }

		export { Query }

		export { QueryBooleanOption }

		export { QueryCache }

		export { QueryCacheNotifyEvent }

		export { QueryClient }

		export { QueryClientConfig }

		declare const QueryClientContext: React_2.Context<QueryClient \| undefined>;
		export { QueryClientContext }
		export { QueryClientContext as QueryClientContext_alias_1 }

		declare const QueryClientProvider: ({ client, children, }: QueryClientProviderProps) => React_2.JSX.Element;
		export { QueryClientProvider }
		export { QueryClientProvider as QueryClientProvider_alias_1 }

		declare type QueryClientProviderProps = {
		client: QueryClient;
		children?: React_2.ReactNode;
		};
		export { QueryClientProviderProps }
		export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }

		declare type QueryErrorClearResetFunction = () => void;
		export { QueryErrorClearResetFunction }
		export { QueryErrorClearResetFunction as QueryErrorClearResetFunction_alias_1 }

		declare type QueryErrorIsResetFunction = () => boolean;
		export { QueryErrorIsResetFunction }
		export { QueryErrorIsResetFunction as QueryErrorIsResetFunction_alias_1 }

		declare const QueryErrorResetBoundary: ({ children, }: QueryErrorResetBoundaryProps) => JSX.Element;
		export { QueryErrorResetBoundary }
		export { QueryErrorResetBoundary as QueryErrorResetBoundary_alias_1 }

		declare type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React_2.ReactNode;
		export { QueryErrorResetBoundaryFunction }
		export { QueryErrorResetBoundaryFunction as QueryErrorResetBoundaryFunction_alias_1 }

		declare interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React_2.ReactNode;
		}
		export { QueryErrorResetBoundaryProps }
		export { QueryErrorResetBoundaryProps as QueryErrorResetBoundaryProps_alias_1 }

		export declare interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}

		declare type QueryErrorResetFunction = () => void;
		export { QueryErrorResetFunction }
		export { QueryErrorResetFunction as QueryErrorResetFunction_alias_1 }

		export { QueryFilters }

		export { QueryFunction }

		export { QueryFunctionContext }

		export { QueryKey }

		export { QueryKeyHashFunction }

		export { QueryMeta }

		export { QueryObserver }

		export { QueryObserverBaseResult }

		export { QueryObserverLoadingErrorResult }

		export { QueryObserverLoadingResult }

		export { QueryObserverOptions }

		export { QueryObserverPendingResult }

		export { QueryObserverPlaceholderResult }

		export { QueryObserverRefetchErrorResult }

		export { QueryObserverResult }

		export { QueryObserverSuccessResult }

		export { QueryOptions }

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};
		export { queryOptions }
		export { queryOptions as queryOptions_alias_1 }

		export { QueryPersister }

		export { QueryState }

		export { QueryStatus }

		export { RefetchOptions }

		export { RefetchQueryFilters }

		export { Register }

		export { replaceEqualDeep }

		export { ResetOptions }

		export { ResultOptions }

		export { SetDataOptions }

		export declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;

		export { shouldThrowError }

		export { SkipToken }

		export { skipToken }

		declare type SkipTokenForUseQueries = symbol;

		declare type SkipTokenForUseQueries_2 = symbol;

		export { StaleTime }

		export { StaleTimeFunction }

		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryOptions<Head>
		], [
		...TDepth,
		1
		]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		export { SuspenseQueriesOptions }
		export { SuspenseQueriesOptions as SuspenseQueriesOptions_alias_1 }

		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		declare type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseSuspenseQueryResult<T[K]>;
		};
		export { SuspenseQueriesResults }
		export { SuspenseQueriesResults as SuspenseQueriesResults_alias_1 }

		export { ThrowOnError }

		export { TimeoutCallback }

		export { timeoutManager }

		export { TimeoutProvider }

		declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		export { UndefinedInitialDataInfiniteOptions }
		export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }

		declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		export { UndefinedInitialDataOptions }
		export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }

		export { UnsetMarker }

		export { unsetMarker }

		declare type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenInfiniteOptions }
		export { UnusedSkipTokenInfiniteOptions as UnusedSkipTokenInfiniteOptions_alias_1 }

		declare type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenOptions }
		export { UnusedSkipTokenOptions as UnusedSkipTokenOptions_alias_1 }

		export { Updater }

		declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		export { UseBaseMutationResult }
		export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }

		export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;

		declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseBaseQueryOptions }
		export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }

		declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		export { UseBaseQueryResult }
		export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }

		export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		export { useInfiniteQuery }
		export { useInfiniteQuery as useInfiniteQuery_alias_1 }

		declare interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseInfiniteQueryOptions }
		export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }

		declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		export { UseInfiniteQueryResult }
		export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }

		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		export { useIsFetching }
		export { useIsFetching as useIsFetching_alias_1 }

		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		export { useIsMutating }
		export { useIsMutating as useIsMutating_alias_1 }

		declare const useIsRestoring: () => boolean;
		export { useIsRestoring }
		export { useIsRestoring as useIsRestoring_alias_1 }

		declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutateAsyncFunction }
		export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }

		declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		export { UseMutateFunction }
		export { UseMutateFunction as UseMutateFunction_alias_1 }

		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { useMutation }
		export { useMutation as useMutation_alias_1 }

		declare interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
		}
		export { UseMutationOptions }
		export { UseMutationOptions as UseMutationOptions_alias_1 }

		declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutationResult }
		export { UseMutationResult as UseMutationResult_alias_1 }

		declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult>, queryClient?: QueryClient): Array<TResult>;
		export { useMutationState }
		export { useMutationState as useMutationState_alias_1 }

		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		export { usePrefetchInfiniteQuery }
		export { usePrefetchInfiniteQuery as usePrefetchInfiniteQuery_alias_1 }

		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): void;
		export { usePrefetchQuery }
		export { usePrefetchQuery as usePrefetchQuery_alias_1 }

		declare interface UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> {
		queryFn?: Exclude<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UsePrefetchQueryOptions }
		export { UsePrefetchQueryOptions as UsePrefetchQueryOptions_alias_1 }

		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
		}];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useQueries }
		export { useQueries as useQueries_alias_1 }

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
		export { useQuery }
		export { useQuery as useQuery_alias_1 }

		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		export { useQueryClient }
		export { useQueryClient as useQueryClient_alias_1 }

		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		export { useQueryErrorResetBoundary }
		export { useQueryErrorResetBoundary as useQueryErrorResetBoundary_alias_1 }

		declare interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
		}
		export { UseQueryOptions }
		export { UseQueryOptions as UseQueryOptions_alias_1 }

		declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};

		declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		export { UseQueryResult }
		export { UseQueryResult as UseQueryResult_alias_1 }

		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		export { useSuspenseInfiniteQuery }
		export { useSuspenseInfiniteQuery as useSuspenseInfiniteQuery_alias_1 }

		declare interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		export { UseSuspenseInfiniteQueryOptions }
		export { UseSuspenseInfiniteQueryOptions as UseSuspenseInfiniteQueryOptions_alias_1 }

		declare type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseInfiniteQueryResult }
		export { UseSuspenseInfiniteQueryResult as UseSuspenseInfiniteQueryResult_alias_1 }

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseSuspenseQueryOptions<T[K]>;
		}];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useSuspenseQueries }
		export { useSuspenseQueries as useSuspenseQueries_alias_1 }

		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		export { useSuspenseQuery }
		export { useSuspenseQuery as useSuspenseQuery_alias_1 }

		declare interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UseSuspenseQueryOptions }
		export { UseSuspenseQueryOptions as UseSuspenseQueryOptions_alias_1 }

		declare type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseQueryResult }
		export { UseSuspenseQueryResult as UseSuspenseQueryResult_alias_1 }

		export declare const willFetch: (result: QueryObserverResult<any, any>, isRestoring: boolean) => boolean;

		export { WithRequired }

		export { }

-947

build/modern/_tsup-dts-rollup.d.ts

		import { AnyDataTag } from '@tanstack/query-core';
		import { CancelledError } from '@tanstack/query-core';
		import { CancelOptions } from '@tanstack/query-core';
		import { DataTag } from '@tanstack/query-core';
		import { dataTagErrorSymbol } from '@tanstack/query-core';
		import { dataTagSymbol } from '@tanstack/query-core';
		import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
		import { DefaultError } from '@tanstack/query-core';
		import { DefaultOptions } from '@tanstack/query-core';
		import { defaultScheduler } from '@tanstack/query-core';
		import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
		import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
		import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
		import { DefinedQueryObserverResult } from '@tanstack/query-core';
		import { dehydrate } from '@tanstack/query-core';
		import { DehydratedState } from '@tanstack/query-core';
		import { DehydrateOptions } from '@tanstack/query-core';
		import { DistributiveOmit } from '@tanstack/query-core';
		import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
		import { EnsureQueryDataOptions } from '@tanstack/query-core';
		import { environmentManager } from '@tanstack/query-core';
		import { experimental_streamedQuery } from '@tanstack/query-core';
		import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
		import { FetchNextPageOptions } from '@tanstack/query-core';
		import { FetchPreviousPageOptions } from '@tanstack/query-core';
		import { FetchQueryOptions } from '@tanstack/query-core';
		import { FetchStatus } from '@tanstack/query-core';
		import { focusManager } from '@tanstack/query-core';
		import { GetNextPageParamFunction } from '@tanstack/query-core';
		import { GetPreviousPageParamFunction } from '@tanstack/query-core';
		import { hashKey } from '@tanstack/query-core';
		import { hydrate } from '@tanstack/query-core';
		import { HydrateOptions } from '@tanstack/query-core';
		import { InferDataFromTag } from '@tanstack/query-core';
		import { InferErrorFromTag } from '@tanstack/query-core';
		import { InfiniteData } from '@tanstack/query-core';
		import { InfiniteQueryObserver } from '@tanstack/query-core';
		import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverOptions } from '@tanstack/query-core';
		import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverResult } from '@tanstack/query-core';
		import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
		import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
		import { InitialDataFunction } from '@tanstack/query-core';
		import { InitialPageParam } from '@tanstack/query-core';
		import { InvalidateOptions } from '@tanstack/query-core';
		import { InvalidateQueryFilters } from '@tanstack/query-core';
		import { isCancelledError } from '@tanstack/query-core';
		import { isServer } from '@tanstack/query-core';
		import { JSX } from 'react/jsx-runtime';
		import { keepPreviousData } from '@tanstack/query-core';
		import { ManagedTimerId } from '@tanstack/query-core';
		import { matchMutation } from '@tanstack/query-core';
		import { matchQuery } from '@tanstack/query-core';
		import { MutateFunction } from '@tanstack/query-core';
		import { MutateOptions } from '@tanstack/query-core';
		import { Mutation } from '@tanstack/query-core';
		import { MutationCache } from '@tanstack/query-core';
		import { MutationCacheNotifyEvent } from '@tanstack/query-core';
		import { MutationFilters } from '@tanstack/query-core';
		import { MutationFunction } from '@tanstack/query-core';
		import { MutationFunctionContext } from '@tanstack/query-core';
		import { MutationKey } from '@tanstack/query-core';
		import { MutationMeta } from '@tanstack/query-core';
		import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
		import { MutationObserverBaseResult } from '@tanstack/query-core';
		import { MutationObserverErrorResult } from '@tanstack/query-core';
		import { MutationObserverIdleResult } from '@tanstack/query-core';
		import { MutationObserverLoadingResult } from '@tanstack/query-core';
		import { MutationObserverOptions } from '@tanstack/query-core';
		import { MutationObserverResult } from '@tanstack/query-core';
		import { MutationObserverSuccessResult } from '@tanstack/query-core';
		import { MutationOptions } from '@tanstack/query-core';
		import { MutationScope } from '@tanstack/query-core';
		import { MutationState } from '@tanstack/query-core';
		import { MutationStatus } from '@tanstack/query-core';
		import { NetworkMode } from '@tanstack/query-core';
		import { NonUndefinedGuard } from '@tanstack/query-core';
		import { noop } from '@tanstack/query-core';
		import { NotifyEvent } from '@tanstack/query-core';
		import { NotifyEventType } from '@tanstack/query-core';
		import { notifyManager } from '@tanstack/query-core';
		import { NotifyOnChangeProps } from '@tanstack/query-core';
		import { OmitKeyof } from '@tanstack/query-core';
		import { onlineManager } from '@tanstack/query-core';
		import { Override } from '@tanstack/query-core';
		import { partialMatchKey } from '@tanstack/query-core';
		import { PlaceholderDataFunction } from '@tanstack/query-core';
		import { QueriesObserver } from '@tanstack/query-core';
		import { QueriesObserverOptions } from '@tanstack/query-core';
		import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
		import { Query } from '@tanstack/query-core';
		import { QueryBooleanOption } from '@tanstack/query-core';
		import { QueryCache } from '@tanstack/query-core';
		import { QueryCacheNotifyEvent } from '@tanstack/query-core';
		import { QueryClient } from '@tanstack/query-core';
		import { QueryClientConfig } from '@tanstack/query-core';
		import { QueryFilters } from '@tanstack/query-core';
		import { QueryFunction } from '@tanstack/query-core';
		import { QueryFunctionContext } from '@tanstack/query-core';
		import { QueryKey } from '@tanstack/query-core';
		import { QueryKeyHashFunction } from '@tanstack/query-core';
		import { QueryMeta } from '@tanstack/query-core';
		import { QueryObserver } from '@tanstack/query-core';
		import { QueryObserverBaseResult } from '@tanstack/query-core';
		import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
		import { QueryObserverLoadingResult } from '@tanstack/query-core';
		import { QueryObserverOptions } from '@tanstack/query-core';
		import { QueryObserverPendingResult } from '@tanstack/query-core';
		import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
		import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
		import { QueryObserverResult } from '@tanstack/query-core';
		import { QueryObserverSuccessResult } from '@tanstack/query-core';
		import { QueryOptions } from '@tanstack/query-core';
		import { QueryPersister } from '@tanstack/query-core';
		import { QueryState } from '@tanstack/query-core';
		import { QueryStatus } from '@tanstack/query-core';
		import * as React_2 from 'react';
		import { RefetchOptions } from '@tanstack/query-core';
		import { RefetchQueryFilters } from '@tanstack/query-core';
		import { Register } from '@tanstack/query-core';
		import { replaceEqualDeep } from '@tanstack/query-core';
		import { ResetOptions } from '@tanstack/query-core';
		import { ResultOptions } from '@tanstack/query-core';
		import { SetDataOptions } from '@tanstack/query-core';
		import { shouldThrowError } from '@tanstack/query-core';
		import { SkipToken } from '@tanstack/query-core';
		import { skipToken } from '@tanstack/query-core';
		import { StaleTime } from '@tanstack/query-core';
		import { StaleTimeFunction } from '@tanstack/query-core';
		import { ThrowOnError } from '@tanstack/query-core';
		import { TimeoutCallback } from '@tanstack/query-core';
		import { timeoutManager } from '@tanstack/query-core';
		import { TimeoutProvider } from '@tanstack/query-core';
		import { UnsetMarker } from '@tanstack/query-core';
		import { unsetMarker } from '@tanstack/query-core';
		import { Updater } from '@tanstack/query-core';
		import { WithRequired } from '@tanstack/query-core';

		export { AnyDataTag }

		declare type AnyUseBaseQueryOptions = UseBaseQueryOptions<any, any, any, any, any>;
		export { AnyUseBaseQueryOptions }
		export { AnyUseBaseQueryOptions as AnyUseBaseQueryOptions_alias_1 }

		declare type AnyUseInfiniteQueryOptions = UseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseInfiniteQueryOptions }
		export { AnyUseInfiniteQueryOptions as AnyUseInfiniteQueryOptions_alias_1 }

		declare type AnyUseMutationOptions = UseMutationOptions<any, any, any, any>;
		export { AnyUseMutationOptions }
		export { AnyUseMutationOptions as AnyUseMutationOptions_alias_1 }

		declare type AnyUseQueryOptions = UseQueryOptions<any, any, any, any>;
		export { AnyUseQueryOptions }
		export { AnyUseQueryOptions as AnyUseQueryOptions_alias_1 }

		declare type AnyUseSuspenseInfiniteQueryOptions = UseSuspenseInfiniteQueryOptions<any, any, any, any, any>;
		export { AnyUseSuspenseInfiniteQueryOptions }
		export { AnyUseSuspenseInfiniteQueryOptions as AnyUseSuspenseInfiniteQueryOptions_alias_1 }

		declare type AnyUseSuspenseQueryOptions = UseSuspenseQueryOptions<any, any, any, any>;
		export { AnyUseSuspenseQueryOptions }
		export { AnyUseSuspenseQueryOptions as AnyUseSuspenseQueryOptions_alias_1 }

		export { CancelledError }

		export { CancelOptions }

		export { DataTag }

		export { dataTagErrorSymbol }

		export { dataTagSymbol }

		export { DefaultedInfiniteQueryObserverOptions }

		export { DefaultedQueryObserverOptions }

		export { DefaultError }

		export { DefaultOptions }

		export { defaultScheduler }

		export { defaultShouldDehydrateMutation }

		export { defaultShouldDehydrateQuery }

		export declare const defaultThrowOnError: <TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(_error: TError, query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean;

		export { DefinedInfiniteQueryObserverResult }

		declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>) \| undefined;
		};
		export { DefinedInitialDataInfiniteOptions }
		export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }

		declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		initialData: NonUndefinedGuard<TQueryFnData> \| (() => NonUndefinedGuard<TQueryFnData>);
		queryFn?: QueryFunction<TQueryFnData, TQueryKey>;
		};
		export { DefinedInitialDataOptions }
		export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }

		export { DefinedQueryObserverResult }

		declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
		export { DefinedUseInfiniteQueryResult }
		export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }

		declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
		export { DefinedUseQueryResult }
		export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }

		export { dehydrate }

		export { DehydratedState }

		export { DehydrateOptions }

		export { DistributiveOmit }

		export { EnsureInfiniteQueryDataOptions }

		export declare const ensurePreventErrorBoundaryRetry: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue, query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined) => void;

		export { EnsureQueryDataOptions }

		export declare const ensureSuspenseTimers: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>) => void;

		export { environmentManager }

		export { experimental_streamedQuery }

		export { FetchInfiniteQueryOptions }

		export { FetchNextPageOptions }

		export declare const fetchOptimistic: <TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(defaultedOptions: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>, errorResetBoundary: QueryErrorResetBoundaryValue) => Promise<void \| QueryObserverResult<TData, TError>>;

		export { FetchPreviousPageOptions }

		export { FetchQueryOptions }

		export { FetchStatus }

		export { focusManager }

		declare type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
		initialData?: infer TInitialData;
		} ? unknown extends TInitialData ? UseQueryResult<TData, TError> : TInitialData extends TData ? DefinedUseQueryResult<TData, TError> : TInitialData extends () => infer TInitialDataResult ? unknown extends TInitialDataResult ? UseQueryResult<TData, TError> : TInitialDataResult extends TData ? DefinedUseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError> : UseQueryResult<TData, TError>;

		export declare const getHasError: <TData, TError, TQueryFnData, TQueryData, TQueryKey extends QueryKey>({ result, errorResetBoundary, throwOnError, query, suspense, }: {
		result: QueryObserverResult<TData, TError>;
		errorResetBoundary: QueryErrorResetBoundaryValue;
		throwOnError: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
		query: Query<TQueryFnData, TError, TQueryData, TQueryKey> \| undefined;
		suspense: boolean \| undefined;
		}) => boolean \| undefined;

		export { GetNextPageParamFunction }

		export { GetPreviousPageParamFunction }

		declare type GetUseQueryOptionsForUseQueries<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;

		declare type GetUseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [any, infer TError, infer TData] ? GetDefinedOrUndefinedQueryResult<T, TData, TError> : T extends [infer TQueryFnData, infer TError] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError> : T extends [infer TQueryFnData] ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? GetDefinedOrUndefinedQueryResult<T, unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;

		declare type GetUseSuspenseQueryOptions<T> = T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryOptions<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseSuspenseQueryOptions<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryOptions<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryOptions<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey> : UseSuspenseQueryOptions;

		declare type GetUseSuspenseQueryResult<T> = T extends {
		queryFnData: any;
		error?: infer TError;
		data: infer TData;
		} ? UseSuspenseQueryResult<TData, TError> : T extends {
		queryFnData: infer TQueryFnData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends {
		data: infer TData;
		error?: infer TError;
		} ? UseSuspenseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseSuspenseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseSuspenseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseSuspenseQueryResult<TQueryFnData> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		select?: (data: any) => infer TData;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : T extends {
		queryFn?: QueryFunction<infer TQueryFnData, any> \| SkipTokenForUseQueries_2;
		throwOnError?: ThrowOnError<any, infer TError, any, any>;
		} ? UseSuspenseQueryResult<TQueryFnData, unknown extends TError ? DefaultError : TError> : UseSuspenseQueryResult;

		export { hashKey }

		export { hydrate }

		export { HydrateOptions }

		declare const HydrationBoundary: ({ children, options, state, queryClient, }: HydrationBoundaryProps) => React_2.ReactElement;
		export { HydrationBoundary }
		export { HydrationBoundary as HydrationBoundary_alias_1 }

		declare interface HydrationBoundaryProps {
		state: DehydratedState \| null \| undefined;
		options?: OmitKeyof<HydrateOptions, 'defaultOptions'> & {
		defaultOptions?: OmitKeyof<Exclude<HydrateOptions['defaultOptions'], undefined>, 'mutations'>;
		};
		children?: React_2.ReactNode;
		queryClient?: QueryClient;
		}
		export { HydrationBoundaryProps }
		export { HydrationBoundaryProps as HydrationBoundaryProps_alias_1 }

		export { InferDataFromTag }

		export { InferErrorFromTag }

		export { InfiniteData }

		export { InfiniteQueryObserver }

		export { InfiniteQueryObserverBaseResult }

		export { InfiniteQueryObserverLoadingErrorResult }

		export { InfiniteQueryObserverLoadingResult }

		export { InfiniteQueryObserverOptions }

		export { InfiniteQueryObserverPendingResult }

		export { InfiniteQueryObserverPlaceholderResult }

		export { InfiniteQueryObserverRefetchErrorResult }

		export { InfiniteQueryObserverResult }

		export { InfiniteQueryObserverSuccessResult }

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};

		declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
		};
		export { infiniteQueryOptions }
		export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }

		export { InfiniteQueryPageParamsOptions }

		export { InitialDataFunction }

		export { InitialPageParam }

		export { InvalidateOptions }

		export { InvalidateQueryFilters }

		export { isCancelledError }

		declare const IsRestoringProvider: React_2.Provider<boolean>;
		export { IsRestoringProvider }
		export { IsRestoringProvider as IsRestoringProvider_alias_1 }

		export { isServer }

		export { keepPreviousData }

		export { ManagedTimerId }

		export { matchMutation }

		export { matchQuery }

		declare type MAXIMUM_DEPTH = 20;

		declare type MAXIMUM_DEPTH_2 = 20;

		export { MutateFunction }

		export { MutateOptions }

		export { Mutation }

		export { MutationCache }

		export { MutationCacheNotifyEvent }

		export { MutationFilters }

		export { MutationFunction }

		export { MutationFunctionContext }

		export { MutationKey }

		export { MutationMeta }

		export { MutationObserver_2 as MutationObserver }

		export { MutationObserverBaseResult }

		export { MutationObserverErrorResult }

		export { MutationObserverIdleResult }

		export { MutationObserverLoadingResult }

		export { MutationObserverOptions }

		export { MutationObserverResult }

		export { MutationObserverSuccessResult }

		export { MutationOptions }

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;

		declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
		export { mutationOptions }
		export { mutationOptions as mutationOptions_alias_1 }

		export { MutationScope }

		export { MutationState }

		declare type MutationStateOptions<TResult = MutationState> = {
		filters?: MutationFilters;
		select?: (mutation: Mutation) => TResult;
		};

		export { MutationStatus }

		export { NetworkMode }

		export { NonUndefinedGuard }

		export { noop }

		export { NotifyEvent }

		export { NotifyEventType }

		export { notifyManager }

		export { NotifyOnChangeProps }

		export { OmitKeyof }

		export { onlineManager }

		export { Override }

		export { partialMatchKey }

		export { PlaceholderDataFunction }

		export { QueriesObserver }

		export { QueriesObserverOptions }

		/**
		* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryOptionsForUseQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseQueryOptionsForUseQueries<Head>
		], [
		...TDepth,
		1
		]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
		export { QueriesOptions }
		export { QueriesOptions as QueriesOptions_alias_1 }

		export { QueriesPlaceholderDataFunction }

		/**
		* QueriesResults reducer recursively maps type param to results
		*/
		declare type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseQueryResult<T[K]>;
		};
		export { QueriesResults }
		export { QueriesResults as QueriesResults_alias_1 }

		export { Query }

		export { QueryBooleanOption }

		export { QueryCache }

		export { QueryCacheNotifyEvent }

		export { QueryClient }

		export { QueryClientConfig }

		declare const QueryClientContext: React_2.Context<QueryClient \| undefined>;
		export { QueryClientContext }
		export { QueryClientContext as QueryClientContext_alias_1 }

		declare const QueryClientProvider: ({ client, children, }: QueryClientProviderProps) => React_2.JSX.Element;
		export { QueryClientProvider }
		export { QueryClientProvider as QueryClientProvider_alias_1 }

		declare type QueryClientProviderProps = {
		client: QueryClient;
		children?: React_2.ReactNode;
		};
		export { QueryClientProviderProps }
		export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }

		declare type QueryErrorClearResetFunction = () => void;
		export { QueryErrorClearResetFunction }
		export { QueryErrorClearResetFunction as QueryErrorClearResetFunction_alias_1 }

		declare type QueryErrorIsResetFunction = () => boolean;
		export { QueryErrorIsResetFunction }
		export { QueryErrorIsResetFunction as QueryErrorIsResetFunction_alias_1 }

		declare const QueryErrorResetBoundary: ({ children, }: QueryErrorResetBoundaryProps) => JSX.Element;
		export { QueryErrorResetBoundary }
		export { QueryErrorResetBoundary as QueryErrorResetBoundary_alias_1 }

		declare type QueryErrorResetBoundaryFunction = (value: QueryErrorResetBoundaryValue) => React_2.ReactNode;
		export { QueryErrorResetBoundaryFunction }
		export { QueryErrorResetBoundaryFunction as QueryErrorResetBoundaryFunction_alias_1 }

		declare interface QueryErrorResetBoundaryProps {
		children: QueryErrorResetBoundaryFunction \| React_2.ReactNode;
		}
		export { QueryErrorResetBoundaryProps }
		export { QueryErrorResetBoundaryProps as QueryErrorResetBoundaryProps_alias_1 }

		export declare interface QueryErrorResetBoundaryValue {
		clearReset: QueryErrorClearResetFunction;
		isReset: QueryErrorIsResetFunction;
		reset: QueryErrorResetFunction;
		}

		declare type QueryErrorResetFunction = () => void;
		export { QueryErrorResetFunction }
		export { QueryErrorResetFunction as QueryErrorResetFunction_alias_1 }

		export { QueryFilters }

		export { QueryFunction }

		export { QueryFunctionContext }

		export { QueryKey }

		export { QueryKeyHashFunction }

		export { QueryMeta }

		export { QueryObserver }

		export { QueryObserverBaseResult }

		export { QueryObserverLoadingErrorResult }

		export { QueryObserverLoadingResult }

		export { QueryObserverOptions }

		export { QueryObserverPendingResult }

		export { QueryObserverPlaceholderResult }

		export { QueryObserverRefetchErrorResult }

		export { QueryObserverResult }

		export { QueryObserverSuccessResult }

		export { QueryOptions }

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};

		declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
		queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
		};
		export { queryOptions }
		export { queryOptions as queryOptions_alias_1 }

		export { QueryPersister }

		export { QueryState }

		export { QueryStatus }

		export { RefetchOptions }

		export { RefetchQueryFilters }

		export { Register }

		export { replaceEqualDeep }

		export { ResetOptions }

		export { ResultOptions }

		export { SetDataOptions }

		export declare const shouldSuspend: (defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any> \| undefined, result: QueryObserverResult<any, any>) => boolean \| undefined;

		export { shouldThrowError }

		export { SkipToken }

		export { skipToken }

		declare type SkipTokenForUseQueries = symbol;

		declare type SkipTokenForUseQueries_2 = symbol;

		export { StaleTime }

		export { StaleTimeFunction }

		/**
		* SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
		*/
		declare type SuspenseQueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryOptions> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryOptions<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesOptions<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryOptions<Head>
		], [
		...TDepth,
		1
		]> : Array<unknown> extends T ? T : T extends Array<UseSuspenseQueryOptions<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>> : Array<UseSuspenseQueryOptions>;
		export { SuspenseQueriesOptions }
		export { SuspenseQueriesOptions as SuspenseQueriesOptions_alias_1 }

		/**
		* SuspenseQueriesResults reducer recursively maps type param to results
		*/
		declare type SuspenseQueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH_2 ? Array<UseSuspenseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetUseSuspenseQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? SuspenseQueriesResults<[
		...Tails
		], [
		...TResults,
		GetUseSuspenseQueryResult<Head>
		], [
		...TDepth,
		1
		]> : {
		[K in keyof T]: GetUseSuspenseQueryResult<T[K]>;
		};
		export { SuspenseQueriesResults }
		export { SuspenseQueriesResults as SuspenseQueriesResults_alias_1 }

		export { ThrowOnError }

		export { TimeoutCallback }

		export { timeoutManager }

		export { TimeoutProvider }

		declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
		initialData?: undefined \| NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> \| InitialDataFunction<NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>>;
		};
		export { UndefinedInitialDataInfiniteOptions }
		export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }

		declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
		initialData?: undefined \| InitialDataFunction<NonUndefinedGuard<TQueryFnData>> \| NonUndefinedGuard<TQueryFnData>;
		};
		export { UndefinedInitialDataOptions }
		export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }

		export { UnsetMarker }

		export { unsetMarker }

		declare type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenInfiniteOptions }
		export { UnusedSkipTokenInfiniteOptions as UnusedSkipTokenInfiniteOptions_alias_1 }

		declare type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken \| undefined>;
		};
		export { UnusedSkipTokenOptions }
		export { UnusedSkipTokenOptions as UnusedSkipTokenOptions_alias_1 }

		export { Updater }

		declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
		mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
		}> & {
		mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
		};
		export { UseBaseMutationResult }
		export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }

		export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): QueryObserverResult<TData, TError>;

		declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseBaseQueryOptions }
		export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }

		declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
		export { UseBaseQueryResult }
		export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }

		export declare const useClearResetErrorBoundary: (errorResetBoundary: QueryErrorResetBoundaryValue) => void;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): DefinedUseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;

		declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseInfiniteQueryResult<TData, TError>;
		export { useInfiniteQuery }
		export { useInfiniteQuery as useInfiniteQuery_alias_1 }

		declare interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {
		/**
		* Set this to `false` to unsubscribe this observer from updates to the query cache.
		* Defaults to `true`.
		*/
		subscribed?: boolean;
		}
		export { UseInfiniteQueryOptions }
		export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }

		declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
		export { UseInfiniteQueryResult }
		export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }

		declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): number;
		export { useIsFetching }
		export { useIsFetching as useIsFetching_alias_1 }

		declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): number;
		export { useIsMutating }
		export { useIsMutating as useIsMutating_alias_1 }

		declare const useIsRestoring: () => boolean;
		export { useIsRestoring }
		export { useIsRestoring as useIsRestoring_alias_1 }

		declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutateAsyncFunction }
		export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }

		declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
		export { UseMutateFunction }
		export { UseMutateFunction as UseMutateFunction_alias_1 }

		declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { useMutation }
		export { useMutation as useMutation_alias_1 }

		declare interface UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
		}
		export { UseMutationOptions }
		export { UseMutationOptions as UseMutationOptions_alias_1 }

		declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
		export { UseMutationResult }
		export { UseMutationResult as UseMutationResult_alias_1 }

		declare function useMutationState<TResult = MutationState>(options?: MutationStateOptions<TResult>, queryClient?: QueryClient): Array<TResult>;
		export { useMutationState }
		export { useMutationState as useMutationState_alias_1 }

		declare function usePrefetchInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): void;
		export { usePrefetchInfiniteQuery }
		export { usePrefetchInfiniteQuery as usePrefetchInfiniteQuery_alias_1 }

		declare function usePrefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UsePrefetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): void;
		export { usePrefetchQuery }
		export { usePrefetchQuery as usePrefetchQuery_alias_1 }

		declare interface UsePrefetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> {
		queryFn?: Exclude<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UsePrefetchQueryOptions }
		export { UsePrefetchQueryOptions as UsePrefetchQueryOptions_alias_1 }

		declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
		queries: readonly [...QueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]>;
		}];
		combine?: (result: QueriesResults<T>) => TCombinedResult;
		subscribed?: boolean;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useQueries }
		export { useQueries as useQueries_alias_1 }

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;

		declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
		export { useQuery }
		export { useQuery as useQuery_alias_1 }

		declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
		export { useQueryClient }
		export { useQueryClient as useQueryClient_alias_1 }

		declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
		export { useQueryErrorResetBoundary }
		export { useQueryErrorResetBoundary as useQueryErrorResetBoundary_alias_1 }

		declare interface UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {
		}
		export { UseQueryOptions }
		export { UseQueryOptions as UseQueryOptions_alias_1 }

		declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' \| 'subscribed'> & {
		placeholderData?: TQueryFnData \| QueriesPlaceholderDataFunction<TQueryFnData>;
		};

		declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
		export { UseQueryResult }
		export { UseQueryResult as UseQueryResult_alias_1 }

		declare function useSuspenseInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: QueryClient): UseSuspenseInfiniteQueryResult<TData, TError>;
		export { useSuspenseInfiniteQuery }
		export { useSuspenseInfiniteQuery as useSuspenseInfiniteQuery_alias_1 }

		declare interface UseSuspenseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>['queryFn'], SkipToken>;
		}
		export { UseSuspenseInfiniteQueryOptions }
		export { UseSuspenseInfiniteQueryOptions as UseSuspenseInfiniteQueryOptions_alias_1 }

		declare type UseSuspenseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitKeyof<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseInfiniteQueryResult }
		export { UseSuspenseInfiniteQueryResult as UseSuspenseInfiniteQueryResult_alias_1 }

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>] \| readonly [...{
		[K in keyof T]: GetUseSuspenseQueryOptions<T[K]>;
		}];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;

		declare function useSuspenseQueries<T extends Array<any>, TCombinedResult = SuspenseQueriesResults<T>>(options: {
		queries: readonly [...SuspenseQueriesOptions<T>];
		combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult;
		}, queryClient?: QueryClient): TCombinedResult;
		export { useSuspenseQueries }
		export { useSuspenseQueries as useSuspenseQueries_alias_1 }

		declare function useSuspenseQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseSuspenseQueryResult<TData, TError>;
		export { useSuspenseQuery }
		export { useSuspenseQuery as useSuspenseQuery_alias_1 }

		declare interface UseSuspenseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn' \| 'enabled' \| 'throwOnError' \| 'placeholderData'> {
		queryFn?: Exclude<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>['queryFn'], SkipToken>;
		}
		export { UseSuspenseQueryOptions }
		export { UseSuspenseQueryOptions as UseSuspenseQueryOptions_alias_1 }

		declare type UseSuspenseQueryResult<TData = unknown, TError = DefaultError> = DistributiveOmit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData' \| 'promise'>;
		export { UseSuspenseQueryResult }
		export { UseSuspenseQueryResult as UseSuspenseQueryResult_alias_1 }

		export declare const willFetch: (result: QueryObserverResult<any, any>, isRestoring: boolean) => boolean;

		export { WithRequired }

		export { }

@tanstack/react-query - npm Package Compare versions

Improved metrics

Worsened metrics

Dependency changes