mtxuilib 0.0.340 → 0.0.344

package/dist/connectes/ConnectEs.cjs

@@ -0,0 +1,43 @@
+"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);
+var ConnectEs_exports = {};
+__export(ConnectEs_exports, {
+  ConnectLoadIfNoDefaultValues: () => ConnectLoadIfNoDefaultValues
+});
+module.exports = __toCommonJS(ConnectEs_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_connectquery = require("./connectquery");
+function ConnectLoadIfNoDefaultValues(props) {
+  const { defauleValues, methodSig, params, children } = props;
+  if (!defauleValues) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Suspense, { fallback: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: "loading4" }), children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Load, { methodSig, params, children }) });
+  }
+  return children(defauleValues);
+}
+function Load(props) {
+  const { methodSig, params, children } = props;
+  const query = (0, import_connectquery.useSuspenseQuery)(methodSig, params);
+  return children && children(query.data);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectLoadIfNoDefaultValues
+});

package/dist/connectes/connectquery/call-unary-method.cjs

@@ -0,0 +1,71 @@
+"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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var call_unary_method_exports = {};
+__export(call_unary_method_exports, {
+  callUnaryMethod: () => callUnaryMethod
+});
+module.exports = __toCommonJS(call_unary_method_exports);
+var import_protobuf = require("@bufbuild/protobuf");
+function callUnaryMethod(_0, _1, _2) {
+  return __async(this, arguments, function* (methodType, input, {
+    callOptions,
+    transport
+  }) {
+    try {
+      const result = yield transport.unary(
+        { typeName: methodType.service.typeName, methods: {} },
+        methodType,
+        callOptions == null ? void 0 : callOptions.signal,
+        callOptions == null ? void 0 : callOptions.timeoutMs,
+        callOptions == null ? void 0 : callOptions.headers,
+        input != null ? input : {}
+      );
+      return (0, import_protobuf.toPlainMessage)(result.message);
+    } catch (e) {
+      return {
+        error_message: e == null ? void 0 : e.toString(),
+        error_code: "unary_call_error"
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callUnaryMethod
+});

package/dist/connectes/connectquery/connect-query-key.cjs

@@ -0,0 +1,40 @@
+"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);
+var connect_query_key_exports = {};
+__export(connect_query_key_exports, {
+  createConnectInfiniteQueryKey: () => createConnectInfiniteQueryKey,
+  createConnectQueryKey: () => createConnectQueryKey
+});
+module.exports = __toCommonJS(connect_query_key_exports);
+var import_utils = require("./utils");
+function createConnectQueryKey(methodDescriptor, input) {
+  return [
+    methodDescriptor.service.typeName,
+    methodDescriptor.name,
+    input === import_utils.disableQuery || !input ? {} : input
+  ];
+}
+function createConnectInfiniteQueryKey(methodDescriptor, input) {
+  return [...createConnectQueryKey(methodDescriptor, input), "infinite"];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConnectInfiniteQueryKey,
+  createConnectQueryKey
+});

package/dist/connectes/connectquery/create-use-infinite-query-options.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var create_use_infinite_query_options_exports = {};
+__export(create_use_infinite_query_options_exports, {
+  createUseInfiniteQueryOptions: () => createUseInfiniteQueryOptions
+});
+module.exports = __toCommonJS(create_use_infinite_query_options_exports);
+var import_call_unary_method = require("./call-unary-method");
+var import_connect_query_key = require("./connect-query-key");
+var import_utils = require("./utils");
+function createUnaryInfiniteQueryFn(methodType, input, {
+  callOptions,
+  transport,
+  pageParamKey
+}) {
+  return (context) => __async(this, null, function* () {
+    var _a;
+    (0, import_utils.assert)(input !== import_utils.disableQuery, "Disabled query cannot be fetched");
+    (0, import_utils.assert)("pageParam" in context, "pageParam must be part of context");
+    const inputCombinedWithPageParam = __spreadProps(__spreadValues({}, input), {
+      [pageParamKey]: context.pageParam
+    });
+    console.log("callUnaryMothod", inputCombinedWithPageParam);
+    return (0, import_call_unary_method.callUnaryMethod)(methodType, inputCombinedWithPageParam, {
+      callOptions: __spreadProps(__spreadValues({}, callOptions), {
+        signal: (_a = callOptions == null ? void 0 : callOptions.signal) != null ? _a : context.signal
+      }),
+      transport
+    });
+  });
+}
+function createUseInfiniteQueryOptions(methodSig, input, {
+  transport,
+  getNextPageParam,
+  pageParamKey,
+  callOptions
+}) {
+  const queryKey = (0, import_connect_query_key.createConnectInfiniteQueryKey)(
+    methodSig,
+    input === import_utils.disableQuery ? void 0 : __spreadProps(__spreadValues({}, input), {
+      [pageParamKey]: void 0
+    })
+  );
+  return {
+    getNextPageParam,
+    initialPageParam: input === import_utils.disableQuery ? void 0 : input[pageParamKey],
+    queryKey,
+    queryFn: createUnaryInfiniteQueryFn(methodSig, input, {
+      transport,
+      callOptions,
+      pageParamKey
+    }),
+    enabled: input !== import_utils.disableQuery
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUseInfiniteQueryOptions
+});

package/dist/connectes/connectquery/create-use-query-options.cjs

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var create_use_query_options_exports = {};
+__export(create_use_query_options_exports, {
+  createUseQueryOptions: () => createUseQueryOptions
+});
+module.exports = __toCommonJS(create_use_query_options_exports);
+var import_call_unary_method = require("./call-unary-method");
+var import_connect_query_key = require("./connect-query-key");
+var import_utils = require("./utils");
+function createUnaryQueryFn(methodType, input, {
+  callOptions,
+  transport
+}) {
+  return (context) => __async(this, null, function* () {
+    var _a;
+    (0, import_utils.assert)(input !== import_utils.disableQuery, "Disabled query cannot be fetched");
+    return (0, import_call_unary_method.callUnaryMethod)(methodType, input, {
+      callOptions: __spreadProps(__spreadValues({}, callOptions), {
+        signal: (_a = callOptions == null ? void 0 : callOptions.signal) != null ? _a : context.signal
+      }),
+      transport
+    });
+  });
+}
+function createUseQueryOptions(methodSig, input, {
+  transport,
+  callOptions
+}) {
+  const queryKey = (0, import_connect_query_key.createConnectQueryKey)(methodSig, input);
+  return {
+    queryKey,
+    queryFn: createUnaryQueryFn(methodSig, input, {
+      transport,
+      callOptions
+    }),
+    enabled: input !== import_utils.disableQuery
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUseQueryOptions
+});

package/dist/connectes/connectquery/default-options.cjs

@@ -0,0 +1,43 @@
+"use strict";
+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);
+var default_options_exports = {};
+__export(default_options_exports, {
+  defaultOptions: () => defaultOptions
+});
+module.exports = __toCommonJS(default_options_exports);
+var import_stable_hash = __toESM(require("stable-hash"), 1);
+const defaultOptions = {
+  queries: {
+    queryKeyHashFn: import_stable_hash.default
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultOptions
+});

package/dist/connectes/connectquery/index.cjs

@@ -0,0 +1,65 @@
+"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);
+var connectquery_exports = {};
+__export(connectquery_exports, {
+  TransportProvider: () => import_use_transport.TransportProvider,
+  callUnaryMethod: () => import_call_unary_method.callUnaryMethod,
+  createConnectInfiniteQueryKey: () => import_connect_query_key.createConnectInfiniteQueryKey,
+  createConnectQueryKey: () => import_connect_query_key.createConnectQueryKey,
+  createInfiniteQueryOptions: () => import_create_use_infinite_query_options.createUseInfiniteQueryOptions,
+  createProtobufSafeUpdater: () => import_utils.createProtobufSafeUpdater,
+  createQueryOptions: () => import_create_use_query_options.createUseQueryOptions,
+  defaultOptions: () => import_default_options.defaultOptions,
+  disableQuery: () => import_utils.disableQuery,
+  useInfiniteQuery: () => import_use_infinite_query.useInfiniteQuery,
+  useMutation: () => import_use_mutation.useMutation,
+  useQuery: () => import_use_query.useQuery,
+  useSuspenseInfiniteQuery: () => import_use_infinite_query.useSuspenseInfiniteQuery,
+  useSuspenseQuery: () => import_use_query.useSuspenseQuery,
+  useTransport: () => import_use_transport.useTransport
+});
+module.exports = __toCommonJS(connectquery_exports);
+var import_call_unary_method = require("./call-unary-method");
+var import_connect_query_key = require("./connect-query-key");
+var import_create_use_infinite_query_options = require("./create-use-infinite-query-options");
+var import_create_use_query_options = require("./create-use-query-options");
+var import_default_options = require("./default-options");
+var import_use_infinite_query = require("./use-infinite-query");
+var import_use_mutation = require("./use-mutation");
+var import_use_query = require("./use-query");
+var import_use_transport = require("./use-transport");
+var import_utils = require("./utils");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransportProvider,
+  callUnaryMethod,
+  createConnectInfiniteQueryKey,
+  createConnectQueryKey,
+  createInfiniteQueryOptions,
+  createProtobufSafeUpdater,
+  createQueryOptions,
+  defaultOptions,
+  disableQuery,
+  useInfiniteQuery,
+  useMutation,
+  useQuery,
+  useSuspenseInfiniteQuery,
+  useSuspenseQuery,
+  useTransport
+});

package/dist/connectes/connectquery/method-unary-descriptor.cjs

@@ -0,0 +1,16 @@
+"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);
+var method_unary_descriptor_exports = {};
+module.exports = __toCommonJS(method_unary_descriptor_exports);

package/dist/connectes/connectquery/use-infinite-query.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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);
+var use_infinite_query_exports = {};
+__export(use_infinite_query_exports, {
+  useInfiniteQuery: () => useInfiniteQuery,
+  useSuspenseInfiniteQuery: () => useSuspenseInfiniteQuery
+});
+module.exports = __toCommonJS(use_infinite_query_exports);
+var import_react_query = require("@tanstack/react-query");
+var import_create_use_infinite_query_options = require("./create-use-infinite-query-options");
+var import_use_transport = require("./use-transport");
+function useInfiniteQuery(methodSig, input, _a) {
+  var _b = _a, {
+    transport,
+    callOptions,
+    pageParamKey,
+    getNextPageParam
+  } = _b, options = __objRest(_b, [
+    "transport",
+    "callOptions",
+    "pageParamKey",
+    "getNextPageParam"
+  ]);
+  var _a2;
+  const transportFromCtx = (0, import_use_transport.useTransport)();
+  const baseOptions = (0, import_create_use_infinite_query_options.createUseInfiniteQueryOptions)(methodSig, input, {
+    transport: transport != null ? transport : transportFromCtx,
+    getNextPageParam,
+    pageParamKey,
+    callOptions
+  });
+  const enabled = baseOptions.enabled && ((_a2 = options.enabled) != null ? _a2 : true);
+  return (0, import_react_query.useInfiniteQuery)(__spreadProps(__spreadValues(__spreadValues({}, options), baseOptions), {
+    enabled
+  }));
+}
+function useSuspenseInfiniteQuery(methodSig, input, _c) {
+  var _d = _c, {
+    transport,
+    callOptions,
+    pageParamKey,
+    getNextPageParam
+  } = _d, options = __objRest(_d, [
+    "transport",
+    "callOptions",
+    "pageParamKey",
+    "getNextPageParam"
+  ]);
+  const transportFromCtx = (0, import_use_transport.useTransport)();
+  const baseOptions = (0, import_create_use_infinite_query_options.createUseInfiniteQueryOptions)(methodSig, input, {
+    transport: transport != null ? transport : transportFromCtx,
+    getNextPageParam,
+    pageParamKey,
+    callOptions
+  });
+  return (0, import_react_query.useSuspenseInfiniteQuery)(__spreadValues(__spreadValues({}, options), baseOptions));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useInfiniteQuery,
+  useSuspenseInfiniteQuery
+});