@01.software/sdk 0.29.0 → 0.30.1

package/dist/query.js

@@ -0,0 +1,1786 @@
+// src/core/query/get-query-client.ts
+import {
+  isServer,
+  QueryClient,
+  defaultShouldDehydrateQuery
+} from "@tanstack/react-query";
+function makeQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        // Infinite staleTime: server-fetched data persists until explicitly invalidated.
+        // For browser clients needing fresher data, override per-query:
+        //   useQuery({ ..., staleTime: 5 * 60 * 1000 })
+        staleTime: Number.POSITIVE_INFINITY,
+        refetchOnWindowFocus: false
+      },
+      dehydrate: {
+        shouldDehydrateQuery: (query) => defaultShouldDehydrateQuery(query) || query.state.status === "pending",
+        shouldRedactErrors: () => false
+      }
+    }
+  });
+}
+var browserQueryClient;
+function getQueryClient() {
+  if (isServer) {
+    return makeQueryClient();
+  }
+  if (!browserQueryClient) {
+    browserQueryClient = makeQueryClient();
+  }
+  return browserQueryClient;
+}
+
+// src/core/query/query-keys.ts
+function collectionKeys(collection) {
+  return {
+    all: [collection],
+    lists: () => [collection, "list"],
+    list: (options) => [collection, "list", options],
+    details: () => [collection, "detail"],
+    detail: (id, options) => [collection, "detail", id, options],
+    infinites: () => [collection, "infinite"],
+    infinite: (options) => [collection, "infinite", options]
+  };
+}
+var customerKeys = {
+  all: ["customer"],
+  me: () => ["customer", "me"]
+};
+var productKeys = {
+  listingGroups: (options) => ["products", "listing-groups", "list", options],
+  listingGroupsInfinite: (options) => ["products", "listing-groups", "infinite", options],
+  detail: (params) => ["products", "detail", params],
+  detailAll: () => ["products", "detail"]
+};
+
+// src/core/query/collection-hooks.ts
+import {
+  useQuery as useQueryOriginal,
+  useSuspenseQuery as useSuspenseQueryOriginal,
+  useInfiniteQuery as useInfiniteQueryOriginal,
+  useSuspenseInfiniteQuery as useSuspenseInfiniteQueryOriginal,
+  useMutation as useMutationOriginal
+} from "@tanstack/react-query";
+var PRODUCT_DETAIL_INVALIDATING_COLLECTIONS = /* @__PURE__ */ new Set([
+  "products",
+  "product-variants",
+  "product-options",
+  "product-option-values",
+  "product-categories",
+  "product-tags",
+  "product-collections",
+  "brands",
+  "brand-logos",
+  "images"
+]);
+var DEFAULT_PAGE_SIZE = 20;
+var CollectionHooks = class {
+  constructor(queryClient, collectionClient) {
+    this.queryClient = queryClient;
+    this.collectionClient = collectionClient;
+  }
+  // ===== useQuery =====
+  useQuery(params, options) {
+    const { collection, options: queryOptions } = params;
+    const { placeholderData, ...restOptions } = options ?? {};
+    return useQueryOriginal({
+      queryKey: collectionKeys(collection).list(queryOptions),
+      queryFn: async () => {
+        return await this.collectionClient.from(collection).find(queryOptions);
+      },
+      ...restOptions,
+      // NonFunctionGuard<T> incompatible with generic union types — safe cast
+      ...placeholderData !== void 0 && {
+        placeholderData
+      }
+    });
+  }
+  // ===== useSuspenseQuery =====
+  useSuspenseQuery(params, options) {
+    const { collection, options: queryOptions } = params;
+    return useSuspenseQueryOriginal({
+      queryKey: collectionKeys(collection).list(queryOptions),
+      queryFn: async () => {
+        return await this.collectionClient.from(collection).find(queryOptions);
+      },
+      ...options
+    });
+  }
+  // ===== useQueryById =====
+  useQueryById(params, options) {
+    const { collection, id, options: queryOptions } = params;
+    const { placeholderData, ...restOptions } = options ?? {};
+    return useQueryOriginal({
+      queryKey: collectionKeys(collection).detail(id, queryOptions),
+      queryFn: async () => {
+        return await this.collectionClient.from(collection).findById(id, queryOptions);
+      },
+      ...restOptions,
+      // NonFunctionGuard<T> incompatible with generic union types — safe cast
+      ...placeholderData !== void 0 && {
+        placeholderData
+      }
+    });
+  }
+  // ===== useSuspenseQueryById =====
+  useSuspenseQueryById(params, options) {
+    const { collection, id, options: queryOptions } = params;
+    return useSuspenseQueryOriginal({
+      queryKey: collectionKeys(collection).detail(id, queryOptions),
+      queryFn: async () => {
+        return await this.collectionClient.from(collection).findById(id, queryOptions);
+      },
+      ...options
+    });
+  }
+  // ===== useInfiniteQuery =====
+  useInfiniteQuery(params, options) {
+    const {
+      collection,
+      options: queryOptions,
+      pageSize = DEFAULT_PAGE_SIZE
+    } = params;
+    return useInfiniteQueryOriginal({
+      queryKey: collectionKeys(collection).infinite(queryOptions),
+      queryFn: async ({ pageParam }) => {
+        const response = await this.collectionClient.from(collection).find({ ...queryOptions, page: pageParam, limit: pageSize });
+        return response;
+      },
+      initialPageParam: 1,
+      getNextPageParam: (lastPage) => {
+        return lastPage.hasNextPage ? lastPage.nextPage : void 0;
+      },
+      ...options
+    });
+  }
+  // ===== useSuspenseInfiniteQuery =====
+  useSuspenseInfiniteQuery(params, options) {
+    const {
+      collection,
+      options: queryOptions,
+      pageSize = DEFAULT_PAGE_SIZE
+    } = params;
+    return useSuspenseInfiniteQueryOriginal({
+      queryKey: collectionKeys(collection).infinite(queryOptions),
+      queryFn: async ({ pageParam }) => {
+        const response = await this.collectionClient.from(collection).find({ ...queryOptions, page: pageParam, limit: pageSize });
+        return response;
+      },
+      initialPageParam: 1,
+      getNextPageParam: (lastPage) => {
+        return lastPage.hasNextPage ? lastPage.nextPage : void 0;
+      },
+      ...options
+    });
+  }
+  // ===== prefetchQuery =====
+  async prefetchQuery(params, options) {
+    const { collection, options: queryOptions } = params;
+    return this.queryClient.prefetchQuery({
+      queryKey: collectionKeys(collection).list(queryOptions),
+      queryFn: async () => {
+        return await this.collectionClient.from(collection).find(queryOptions);
+      },
+      ...options
+    });
+  }
+  // ===== prefetchQueryById =====
+  async prefetchQueryById(params, options) {
+    const { collection, id, options: queryOptions } = params;
+    return this.queryClient.prefetchQuery({
+      queryKey: collectionKeys(collection).detail(id, queryOptions),
+      queryFn: async () => {
+        return await this.collectionClient.from(collection).findById(id, queryOptions);
+      },
+      ...options
+    });
+  }
+  // ===== prefetchInfiniteQuery =====
+  async prefetchInfiniteQuery(params, options) {
+    const {
+      collection,
+      options: queryOptions,
+      pageSize = DEFAULT_PAGE_SIZE
+    } = params;
+    return this.queryClient.prefetchInfiniteQuery({
+      queryKey: collectionKeys(collection).infinite(queryOptions),
+      queryFn: async ({ pageParam }) => {
+        const response = await this.collectionClient.from(collection).find({ ...queryOptions, page: pageParam, limit: pageSize });
+        return response;
+      },
+      initialPageParam: 1,
+      getNextPageParam: (lastPage) => {
+        return lastPage.hasNextPage ? lastPage.nextPage : void 0;
+      },
+      pages: options?.pages ?? 1,
+      staleTime: options?.staleTime
+    });
+  }
+  // ===== Mutation Hooks =====
+  useCreate(params, options) {
+    const { collection } = params;
+    return useMutationOriginal({
+      mutationFn: async (variables) => {
+        return await this.collectionClient.from(collection).create(
+          variables.data,
+          variables.file ? { file: variables.file, filename: variables.filename } : void 0
+        );
+      },
+      onSuccess: (data) => {
+        this.queryClient.invalidateQueries({
+          queryKey: collectionKeys(collection).all
+        });
+        if (PRODUCT_DETAIL_INVALIDATING_COLLECTIONS.has(collection)) {
+          this.queryClient.invalidateQueries({ queryKey: ["products", "detail"] });
+        }
+        options?.onSuccess?.(data);
+      },
+      onError: options?.onError,
+      onSettled: options?.onSettled
+    });
+  }
+  useUpdate(params, options) {
+    const { collection } = params;
+    return useMutationOriginal({
+      mutationFn: async (variables) => {
+        return await this.collectionClient.from(collection).update(
+          variables.id,
+          variables.data,
+          variables.file ? { file: variables.file, filename: variables.filename } : void 0
+        );
+      },
+      onSuccess: (data) => {
+        this.queryClient.invalidateQueries({
+          queryKey: collectionKeys(collection).all
+        });
+        if (PRODUCT_DETAIL_INVALIDATING_COLLECTIONS.has(collection)) {
+          this.queryClient.invalidateQueries({ queryKey: ["products", "detail"] });
+        }
+        options?.onSuccess?.(data);
+      },
+      onError: options?.onError,
+      onSettled: options?.onSettled
+    });
+  }
+  useRemove(params, options) {
+    const { collection } = params;
+    return useMutationOriginal({
+      mutationFn: async (id) => {
+        return await this.collectionClient.from(collection).remove(id);
+      },
+      onSuccess: (data) => {
+        this.queryClient.invalidateQueries({
+          queryKey: collectionKeys(collection).all
+        });
+        if (PRODUCT_DETAIL_INVALIDATING_COLLECTIONS.has(collection)) {
+          this.queryClient.invalidateQueries({ queryKey: ["products", "detail"] });
+        }
+        options?.onSuccess?.(data);
+      },
+      onError: options?.onError,
+      onSettled: options?.onSettled
+    });
+  }
+  // ===== Cache Utilities =====
+  invalidateQueries(collection, type) {
+    const queryKey = type ? [collection, type] : [collection];
+    return this.queryClient.invalidateQueries({ queryKey });
+  }
+  getQueryData(collection, type, idOrOptions, options) {
+    if (type === "list") {
+      return this.queryClient.getQueryData(
+        collectionKeys(collection).list(idOrOptions)
+      );
+    }
+    return this.queryClient.getQueryData(
+      collectionKeys(collection).detail(idOrOptions, options)
+    );
+  }
+  setQueryData(collection, type, dataOrId, dataOrOptions, options) {
+    if (type === "list") {
+      this.queryClient.setQueryData(
+        collectionKeys(collection).list(dataOrOptions),
+        dataOrId
+      );
+    } else {
+      this.queryClient.setQueryData(
+        collectionKeys(collection).detail(dataOrId, options),
+        dataOrOptions
+      );
+    }
+  }
+};
+
+// src/core/query/customer-hooks.ts
+import {
+  useQuery as useQueryOriginal2,
+  useMutation as useMutationOriginal2
+} from "@tanstack/react-query";
+
+// src/core/internal/errors/index.ts
+var SDKError = class extends Error {
+  constructor(code, message, status, details, userMessage, suggestion, requestId) {
+    super(message);
+    this.name = "SDKError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.userMessage = userMessage;
+    this.suggestion = suggestion;
+    this.requestId = requestId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+  getUserMessage() {
+    return this.userMessage || this.message;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      status: this.status,
+      details: this.details,
+      userMessage: this.userMessage,
+      suggestion: this.suggestion,
+      ...this.requestId !== void 0 && { requestId: this.requestId }
+    };
+  }
+};
+var NetworkError = class extends SDKError {
+  constructor(message, status, details, userMessage, suggestion) {
+    super("NETWORK_ERROR", message, status, details, userMessage, suggestion);
+    this.name = "NetworkError";
+  }
+};
+var ValidationError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, status = 400) {
+    super("VALIDATION_ERROR", message, status, details, userMessage, suggestion);
+    this.name = "ValidationError";
+  }
+};
+var ApiError = class extends SDKError {
+  constructor(message, status, details, userMessage, suggestion) {
+    super("API_ERROR", message, status, details, userMessage, suggestion);
+    this.name = "ApiError";
+  }
+};
+var ConfigError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion) {
+    super("CONFIG_ERROR", message, void 0, details, userMessage, suggestion);
+    this.name = "ConfigError";
+  }
+};
+var TimeoutError = class extends SDKError {
+  constructor(message = "Request timed out.", details, userMessage, suggestion) {
+    super("TIMEOUT_ERROR", message, 408, details, userMessage, suggestion);
+    this.name = "TimeoutError";
+  }
+};
+var UsageLimitError = class extends SDKError {
+  constructor(message, usage, details, userMessage, suggestion) {
+    super("USAGE_LIMIT_ERROR", message, 429, details, userMessage, suggestion);
+    this.name = "UsageLimitError";
+    this.usage = usage;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      usage: this.usage
+    };
+  }
+};
+var AuthError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("auth_error", message, 401, details, userMessage, suggestion, requestId);
+    this.name = "AuthError";
+  }
+};
+var PermissionError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("permission_error", message, 403, details, userMessage, suggestion, requestId);
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("not_found", message, 404, details, userMessage, suggestion, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("conflict", message, 409, details, userMessage, suggestion, requestId);
+    this.name = "ConflictError";
+  }
+};
+var createNetworkError = (message, status, details, userMessage, suggestion) => new NetworkError(message, status, details, userMessage, suggestion);
+var createValidationError = (message, details, userMessage, suggestion, status) => new ValidationError(message, details, userMessage, suggestion, status);
+var createApiError = (message, status, details, userMessage, suggestion) => new ApiError(message, status, details, userMessage, suggestion);
+var createConfigError = (message, details, userMessage, suggestion) => new ConfigError(message, details, userMessage, suggestion);
+var createTimeoutError = (message, details, userMessage, suggestion) => new TimeoutError(message, details, userMessage, suggestion);
+var createUsageLimitError = (message, usage, details, userMessage, suggestion) => new UsageLimitError(message, usage, details, userMessage, suggestion);
+var createAuthError = (message, details, userMessage, suggestion, requestId) => new AuthError(message, details, userMessage, suggestion, requestId);
+var createPermissionError = (message, details, userMessage, suggestion, requestId) => new PermissionError(message, details, userMessage, suggestion, requestId);
+var createNotFoundError = (message, details, userMessage, suggestion, requestId) => new NotFoundError(message, details, userMessage, suggestion, requestId);
+var createConflictError = (message, details, userMessage, suggestion, requestId) => new ConflictError(message, details, userMessage, suggestion, requestId);
+
+// src/core/query/customer-hooks.ts
+function createMutation(mutationFn, callbacks, onSuccessExtra) {
+  return useMutationOriginal2({
+    mutationFn,
+    onSuccess: (data) => {
+      onSuccessExtra?.(data);
+      callbacks?.onSuccess?.(data);
+    },
+    onError: callbacks?.onError,
+    onSettled: callbacks?.onSettled
+  });
+}
+var CustomerHooks = class {
+  constructor(queryClient, customerAuth) {
+    this.invalidateMe = () => {
+      this.queryClient.invalidateQueries({ queryKey: customerKeys.me() });
+    };
+    this.queryClient = queryClient;
+    this.customerAuth = customerAuth;
+  }
+  ensureCustomerAuth() {
+    if (!this.customerAuth) {
+      throw createConfigError(
+        "Customer hooks require Client. Use createClient() instead of createServerClient()."
+      );
+    }
+    return this.customerAuth;
+  }
+  // ===== useCustomerMe =====
+  useCustomerMe(options) {
+    return useQueryOriginal2({
+      queryKey: customerKeys.me(),
+      queryFn: async () => {
+        return await this.ensureCustomerAuth().me();
+      },
+      ...options,
+      enabled: (options?.enabled ?? true) && !!this.customerAuth?.isAuthenticated()
+    });
+  }
+  // ===== Mutations =====
+  useCustomerLogin(options) {
+    return createMutation(
+      (data) => this.ensureCustomerAuth().login(data),
+      options,
+      this.invalidateMe
+    );
+  }
+  useCustomerRegister(options) {
+    return createMutation(
+      (data) => this.ensureCustomerAuth().register(data),
+      options
+    );
+  }
+  useCustomerLogout(options) {
+    return useMutationOriginal2({
+      mutationFn: async () => {
+        this.ensureCustomerAuth().logout();
+      },
+      onSuccess: () => {
+        this.queryClient.removeQueries({ queryKey: customerKeys.all });
+        options?.onSuccess?.();
+      },
+      onError: options?.onError,
+      onSettled: options?.onSettled
+    });
+  }
+  useCustomerForgotPassword(options) {
+    return createMutation(
+      (email) => this.ensureCustomerAuth().forgotPassword(email).then(() => {
+      }),
+      options
+    );
+  }
+  useCustomerResetPassword(options) {
+    return createMutation(
+      (data) => this.ensureCustomerAuth().resetPassword(data.token, data.password).then(() => {
+      }),
+      options
+    );
+  }
+  useCustomerRefreshToken(options) {
+    return createMutation(
+      () => this.ensureCustomerAuth().refreshToken(),
+      options,
+      this.invalidateMe
+    );
+  }
+  useCustomerUpdateProfile(options) {
+    return createMutation(
+      (data) => this.ensureCustomerAuth().updateProfile(data),
+      options,
+      this.invalidateMe
+    );
+  }
+  useCustomerChangePassword(options) {
+    return createMutation(
+      (data) => this.ensureCustomerAuth().changePassword(data.currentPassword, data.newPassword).then(() => {
+      }),
+      options
+    );
+  }
+  // ===== Customer Cache Utilities =====
+  invalidateCustomerQueries() {
+    return this.queryClient.invalidateQueries({ queryKey: customerKeys.all });
+  }
+  getCustomerData() {
+    return this.queryClient.getQueryData(customerKeys.me());
+  }
+  setCustomerData(data) {
+    this.queryClient.setQueryData(customerKeys.me(), data);
+  }
+};
+
+// src/core/query/query-hooks.ts
+import {
+  useInfiniteQuery as useInfiniteQueryOriginal2,
+  useQuery as useQueryOriginal3,
+  useSuspenseInfiniteQuery as useSuspenseInfiniteQueryOriginal2,
+  useSuspenseQuery as useSuspenseQueryOriginal2
+} from "@tanstack/react-query";
+var QueryHooks = class extends CollectionHooks {
+  constructor(queryClient, collectionClient, customerAuth, commerceClient) {
+    super(queryClient, collectionClient);
+    // --- Customer hooks delegation ---
+    this.useCustomerMe = (...args) => this._customer.useCustomerMe(...args);
+    this.useCustomerLogin = (...args) => this._customer.useCustomerLogin(...args);
+    this.useCustomerRegister = (...args) => this._customer.useCustomerRegister(...args);
+    this.useCustomerLogout = (...args) => this._customer.useCustomerLogout(...args);
+    this.useCustomerForgotPassword = (...args) => this._customer.useCustomerForgotPassword(...args);
+    this.useCustomerResetPassword = (...args) => this._customer.useCustomerResetPassword(...args);
+    this.useCustomerRefreshToken = (...args) => this._customer.useCustomerRefreshToken(...args);
+    this.useCustomerUpdateProfile = (...args) => this._customer.useCustomerUpdateProfile(...args);
+    this.useCustomerChangePassword = (...args) => this._customer.useCustomerChangePassword(...args);
+    // --- Customer cache delegation ---
+    this.invalidateCustomerQueries = () => this._customer.invalidateCustomerQueries();
+    this.getCustomerData = () => this._customer.getCustomerData();
+    this.setCustomerData = (data) => this._customer.setCustomerData(data);
+    this._customer = new CustomerHooks(queryClient, customerAuth);
+    this._commerce = commerceClient;
+  }
+  useProductListingGroupsQuery(params, options) {
+    const queryOptions = params.options;
+    const { placeholderData, ...restOptions } = options ?? {};
+    return useQueryOriginal3({
+      queryKey: productKeys.listingGroups(queryOptions),
+      queryFn: async () => this.collectionClient.requestFindEndpoint(
+        "/api/products/listing-groups/query",
+        { options: queryOptions }
+      ),
+      ...restOptions,
+      ...placeholderData !== void 0 && {
+        placeholderData
+      }
+    });
+  }
+  useSuspenseProductListingGroupsQuery(params, options) {
+    const queryOptions = params.options;
+    return useSuspenseQueryOriginal2({
+      queryKey: productKeys.listingGroups(queryOptions),
+      queryFn: async () => this.collectionClient.requestFindEndpoint(
+        "/api/products/listing-groups/query",
+        { options: queryOptions }
+      ),
+      ...options
+    });
+  }
+  useInfiniteProductListingGroupsQuery(params, options) {
+    const {
+      options: queryOptions,
+      pageSize = 20
+    } = params;
+    return useInfiniteQueryOriginal2({
+      queryKey: productKeys.listingGroupsInfinite(queryOptions),
+      queryFn: async ({ pageParam }) => this.collectionClient.requestFindEndpoint(
+        "/api/products/listing-groups/query",
+        {
+          options: { ...queryOptions, page: pageParam, limit: pageSize }
+        }
+      ),
+      initialPageParam: 1,
+      getNextPageParam: (lastPage) => lastPage.hasNextPage ? lastPage.nextPage : void 0,
+      ...options
+    });
+  }
+  useSuspenseInfiniteProductListingGroupsQuery(params, options) {
+    const {
+      options: queryOptions,
+      pageSize = 20
+    } = params;
+    return useSuspenseInfiniteQueryOriginal2({
+      queryKey: productKeys.listingGroupsInfinite(queryOptions),
+      queryFn: async ({ pageParam }) => this.collectionClient.requestFindEndpoint(
+        "/api/products/listing-groups/query",
+        {
+          options: { ...queryOptions, page: pageParam, limit: pageSize }
+        }
+      ),
+      initialPageParam: 1,
+      getNextPageParam: (lastPage) => lastPage.hasNextPage ? lastPage.nextPage : void 0,
+      ...options
+    });
+  }
+  async prefetchProductListingGroupsQuery(params, options) {
+    const queryOptions = params.options;
+    return this.queryClient.prefetchQuery({
+      queryKey: productKeys.listingGroups(queryOptions),
+      queryFn: async () => this.collectionClient.requestFindEndpoint(
+        "/api/products/listing-groups/query",
+        { options: queryOptions }
+      ),
+      ...options
+    });
+  }
+  async prefetchInfiniteProductListingGroupsQuery(params, options) {
+    const {
+      options: queryOptions,
+      pageSize = 20
+    } = params;
+    return this.queryClient.prefetchInfiniteQuery({
+      queryKey: productKeys.listingGroupsInfinite(queryOptions),
+      queryFn: async ({ pageParam }) => this.collectionClient.requestFindEndpoint(
+        "/api/products/listing-groups/query",
+        {
+          options: { ...queryOptions, page: pageParam, limit: pageSize }
+        }
+      ),
+      initialPageParam: 1,
+      getNextPageParam: (lastPage) => lastPage.hasNextPage ? lastPage.nextPage : void 0,
+      pages: options?.pages ?? 1,
+      staleTime: options?.staleTime
+    });
+  }
+  useProductDetail(params, options) {
+    const discriminator = "slug" in params ? params.slug : params.id;
+    const enabled = options?.enabled !== false && Boolean(discriminator);
+    return useQueryOriginal3({
+      queryKey: productKeys.detail(params),
+      queryFn: () => this._commerce.product.detail(params),
+      enabled
+    });
+  }
+  useProductDetailBySlug(slug, options) {
+    return this.useProductDetail({ slug }, options);
+  }
+  useProductDetailById(id, options) {
+    return this.useProductDetail({ id }, options);
+  }
+};
+
+// src/core/query/realtime.ts
+var INITIAL_RECONNECT_DELAY = 1e3;
+var MAX_RECONNECT_DELAY = 3e4;
+var RECONNECT_BACKOFF_FACTOR = 2;
+var MAX_NO_TOKEN_RETRIES = 5;
+var RealtimeConnection = class {
+  constructor(baseUrl, publishableKey, getToken, collections) {
+    this.baseUrl = baseUrl;
+    this.publishableKey = publishableKey;
+    this.getToken = getToken;
+    this.collections = collections;
+    this.abortController = null;
+    this.reconnectAttempt = 0;
+    this.noTokenAttempts = 0;
+    this.reconnectTimer = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this._connected = false;
+  }
+  get connected() {
+    return this._connected;
+  }
+  addListener(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  connect() {
+    if (this.abortController) return;
+    this.abortController = new AbortController();
+    this.startStream(this.abortController.signal);
+  }
+  disconnect() {
+    this._connected = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.reconnectAttempt = 0;
+    this.noTokenAttempts = 0;
+  }
+  async startStream(signal) {
+    const token = this.getToken();
+    if (!token) {
+      this.noTokenAttempts++;
+      if (this.noTokenAttempts >= MAX_NO_TOKEN_RETRIES) {
+        this._connected = false;
+        this.abortController = null;
+        return;
+      }
+      this.scheduleReconnect();
+      return;
+    }
+    this.noTokenAttempts = 0;
+    const params = this.collections?.length ? `?collections=${this.collections.join(",")}` : "";
+    const url = `${this.baseUrl}/api/events/stream${params}`;
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "X-Publishable-Key": this.publishableKey,
+          Authorization: `Bearer ${token}`
+        },
+        signal
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          this.scheduleReconnect();
+          return;
+        }
+        throw new Error(`SSE connection failed: ${response.status}`);
+      }
+      if (!response.body) {
+        throw new Error("SSE response has no body");
+      }
+      this._connected = true;
+      this.reconnectAttempt = 0;
+      await this.readStream(response.body, signal);
+    } catch {
+      if (signal.aborted) return;
+      this._connected = false;
+      this.scheduleReconnect();
+    }
+  }
+  async readStream(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "";
+    let currentData = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done || signal.aborted) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            currentEvent = line.slice(7);
+          } else if (line.startsWith("data: ")) {
+            currentData += (currentData ? "\n" : "") + line.slice(6);
+          } else if (line === "") {
+            if (currentEvent === "collection:change" && currentData) {
+              try {
+                const event = JSON.parse(currentData);
+                for (const listener of this.listeners) {
+                  try {
+                    listener(event);
+                  } catch {
+                  }
+                }
+              } catch {
+              }
+            }
+            currentEvent = "";
+            currentData = "";
+          }
+        }
+      }
+    } catch {
+    } finally {
+      reader.releaseLock();
+      this._connected = false;
+      if (!signal.aborted) {
+        this.scheduleReconnect();
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    const delay2 = Math.min(
+      INITIAL_RECONNECT_DELAY * Math.pow(RECONNECT_BACKOFF_FACTOR, this.reconnectAttempt),
+      MAX_RECONNECT_DELAY
+    );
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.abortController = new AbortController();
+      this.startStream(this.abortController.signal);
+    }, delay2);
+  }
+};
+
+// src/utils/types.ts
+var resolveRelation = (ref) => {
+  if (typeof ref === "string" || typeof ref === "number" || ref === null || ref === void 0)
+    return null;
+  return ref;
+};
+
+// src/core/metadata/index.ts
+function extractSeo(doc) {
+  const seo = doc.seo ?? {};
+  const og = seo.openGraph ?? {};
+  return {
+    title: seo.title ?? doc.title ?? null,
+    description: seo.description ?? null,
+    noIndex: seo.noIndex ?? null,
+    canonical: seo.canonical ?? null,
+    openGraph: {
+      title: og.title ?? null,
+      description: og.description ?? null,
+      image: og.image ?? null
+    }
+  };
+}
+function generateMetadata(input, options) {
+  const title = input.title ?? void 0;
+  const description = input.description ?? void 0;
+  const ogTitle = input.openGraph?.title ?? title;
+  const ogDescription = input.openGraph?.description ?? description;
+  const image = resolveMetaImage(input.openGraph?.image);
+  return {
+    title,
+    description,
+    ...input.noIndex && { robots: { index: false, follow: false } },
+    ...input.canonical && { alternates: { canonical: input.canonical } },
+    openGraph: {
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...options?.siteName && { siteName: options.siteName },
+      ...image && { images: [image] }
+    },
+    twitter: {
+      card: image ? "summary_large_image" : "summary",
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...image && { images: [image.url] }
+    }
+  };
+}
+function resolveMetaImage(ref) {
+  const image = resolveRelation(ref);
+  if (!image) return null;
+  const sized = image.sizes?.["1536"];
+  const url = sized?.url || image.url;
+  if (!url) return null;
+  const width = sized?.url ? sized.width : image.width;
+  const height = sized?.url ? sized.height : image.height;
+  return {
+    url,
+    ...width && { width },
+    ...height && { height },
+    ...image.alt && { alt: image.alt }
+  };
+}
+
+// src/core/collection/query-builder.ts
+var CollectionQueryBuilder = class {
+  constructor(api, collection) {
+    this.api = api;
+    this.collection = collection;
+  }
+  /**
+   * Find documents (list query)
+   * GET /api/{collection}
+   * @returns Payload CMS find response with docs array and pagination
+   */
+  async find(options) {
+    return this.api.requestFind(
+      `/api/${String(this.collection)}`,
+      options
+    );
+  }
+  /**
+   * Find document by ID
+   * GET /api/{collection}/{id}
+   * @returns Document object directly (no wrapper)
+   */
+  async findById(id, options) {
+    return this.api.requestFindById(
+      `/api/${String(this.collection)}/${String(id)}`,
+      options
+    );
+  }
+  /**
+   * Create a new document
+   * POST /api/{collection}
+   * @returns Payload CMS mutation response with doc and message
+   */
+  async create(data, options) {
+    const endpoint = `/api/${String(this.collection)}`;
+    if (options?.file) {
+      return this.api.requestCreateWithFile(
+        endpoint,
+        data,
+        options.file,
+        options.filename
+      );
+    }
+    return this.api.requestCreate(endpoint, data);
+  }
+  /**
+   * Update a document by ID
+   * PATCH /api/{collection}/{id}
+   * @returns Payload CMS mutation response with doc and message
+   */
+  async update(id, data, options) {
+    const endpoint = `/api/${String(this.collection)}/${String(id)}`;
+    if (options?.file) {
+      return this.api.requestUpdateWithFile(
+        endpoint,
+        data,
+        options.file,
+        options.filename
+      );
+    }
+    return this.api.requestUpdate(endpoint, data);
+  }
+  /**
+   * Count documents
+   * GET /api/{collection}/count
+   * @returns Count response with totalDocs
+   */
+  async count(options) {
+    return this.api.requestCount(
+      `/api/${String(this.collection)}/count`,
+      options
+    );
+  }
+  /**
+   * Find first matching document and return its Next.js Metadata.
+   * Applies depth: 1 (SEO image populate) and limit: 1 automatically.
+   * @returns Metadata or null if no document matches
+   */
+  async findMetadata(options, metadataOptions) {
+    const { docs } = await this.find({ ...options, limit: 1, depth: 1 });
+    const doc = docs[0];
+    if (!doc) return null;
+    return generateMetadata(
+      extractSeo(doc),
+      metadataOptions
+    );
+  }
+  /**
+   * Find document by ID and return its Next.js Metadata.
+   * Applies depth: 1 (SEO image populate) automatically.
+   * @returns Metadata (throws on 404)
+   */
+  async findMetadataById(id, metadataOptions) {
+    const doc = await this.findById(id, { depth: 1 });
+    return generateMetadata(
+      extractSeo(doc),
+      metadataOptions
+    );
+  }
+  /**
+   * Update multiple documents (bulk update)
+   * PATCH /api/{collection}
+   * @returns Payload CMS find response with updated docs
+   */
+  async updateMany(where, data) {
+    return this.api.requestUpdateMany(
+      `/api/${String(this.collection)}`,
+      { where, data }
+    );
+  }
+  /**
+   * Delete a document by ID
+   * DELETE /api/{collection}/{id}
+   * @returns Deleted document object directly (no wrapper)
+   */
+  async remove(id) {
+    return this.api.requestDelete(
+      `/api/${String(this.collection)}/${String(id)}`
+    );
+  }
+  /**
+   * Delete multiple documents (bulk delete)
+   * DELETE /api/{collection}
+   * @returns Payload CMS find response with deleted docs
+   */
+  async removeMany(where) {
+    return this.api.requestDeleteMany(
+      `/api/${String(this.collection)}`,
+      { where }
+    );
+  }
+};
+
+// src/core/collection/http-client.ts
+import { stringify } from "qs-esm";
+
+// src/core/internal/utils/credentials.ts
+function requirePublishableKeyForSecret(apiName, publishableKey, secretKey) {
+  if (secretKey && !publishableKey) {
+    throw createConfigError(
+      `publishableKey is required for ${apiName} when secretKey is used. It is sent as X-Publishable-Key for tenant routing, rate limiting, and quota enforcement.`
+    );
+  }
+  return publishableKey ?? "";
+}
+
+// src/core/client/types.ts
+function resolveApiUrl(apiUrl) {
+  if (apiUrl) {
+    return apiUrl.replace(/\/$/, "");
+  }
+  if (typeof process !== "undefined" && process.env) {
+    const envUrl = process.env.SOFTWARE_API_URL || process.env.NEXT_PUBLIC_SOFTWARE_API_URL;
+    if (envUrl) {
+      return envUrl.replace(/\/$/, "");
+    }
+  }
+  return "https://api.01.software";
+}
+
+// src/core/internal/utils/http.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRYABLE_STATUSES = [408, 429, 500, 502, 503, 504];
+var NON_RETRYABLE_STATUSES = [400, 401, 403, 404, 409, 422];
+var SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
+function debugLog(debug, type, message, data) {
+  if (!debug) return;
+  const shouldLog = debug === true || type === "request" && debug.logRequests || type === "response" && debug.logResponses || type === "error" && debug.logErrors;
+  if (shouldLog) {
+    console.group(`[SDK ${type.toUpperCase()}] ${message}`);
+    if (data) console.log(data);
+    console.groupEnd();
+  }
+}
+function getErrorSuggestion(status) {
+  if (status === 400)
+    return "The request data failed validation. Check field values and types.";
+  if (status === 401) return "Please check your authentication credentials.";
+  if (status === 403)
+    return "Access denied. Check your credentials or permissions.";
+  if (status === 404) return "The requested resource was not found.";
+  if (status === 422) return "The request data failed validation.";
+  if (status >= 500) return "A server error occurred. Please try again later.";
+  return void 0;
+}
+function isUsageLimitExceededResponse(response) {
+  if (response.status !== 429) return false;
+  const limit = parseInt(response.headers.get("X-Usage-Limit") || "", 10);
+  const current = parseInt(response.headers.get("X-Usage-Current") || "", 10);
+  if (!Number.isFinite(limit) || !Number.isFinite(current)) return false;
+  return response.headers.get("X-Usage-Exceeded") === "true" || current > limit;
+}
+async function parseErrorBody(response) {
+  const fallback = {
+    errorMessage: `HTTP ${response.status}: ${response.statusText}`,
+    userMessage: `Request failed (status: ${response.status})`
+  };
+  try {
+    const body = await response.json();
+    const reason = typeof body.reason === "string" ? body.reason : typeof body.code === "string" ? body.code : void 0;
+    if (body.errors && Array.isArray(body.errors)) {
+      const fieldErrors = [];
+      for (const e of body.errors) {
+        if (e.data?.errors && Array.isArray(e.data.errors) && e.data.errors.length > 0) {
+          for (const fe of e.data.errors) {
+            fieldErrors.push({
+              field: fe.path || fe.field,
+              message: fe.message
+            });
+          }
+        } else if (e.field || e.message) {
+          fieldErrors.push({ field: e.field, message: e.message });
+        }
+      }
+      const details = (fieldErrors.length > 0 ? fieldErrors : body.errors).map(
+        (e) => e.field ? `${e.field}: ${e.message}` : e.message
+      ).filter(Boolean).join("; ");
+      if (details) {
+        return {
+          errorMessage: `HTTP ${response.status}: ${details}`,
+          userMessage: details,
+          reason,
+          body,
+          errors: fieldErrors.length > 0 ? fieldErrors : body.errors
+        };
+      }
+    }
+    if (typeof body.error === "string") {
+      return {
+        errorMessage: `HTTP ${response.status}: ${body.error}`,
+        userMessage: body.error,
+        reason,
+        body
+      };
+    }
+    if (body.message) {
+      return {
+        errorMessage: `HTTP ${response.status}: ${body.message}`,
+        userMessage: body.message,
+        reason,
+        body
+      };
+    }
+    return { ...fallback, reason, body };
+  } catch {
+    return fallback;
+  }
+}
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function attachRequestId(err, id) {
+  if (id) err.requestId = id;
+  return err;
+}
+function createHttpStatusError(status, parsed, details, requestId) {
+  const errorDetails = {
+    ...details,
+    ...parsed.errors && { errors: parsed.errors },
+    ...parsed.body && { body: parsed.body }
+  };
+  const suggestion = getErrorSuggestion(status);
+  if (status === 400 || status === 422) {
+    return attachRequestId(
+      createValidationError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion,
+        status
+      ),
+      requestId
+    );
+  }
+  if (status === 401) {
+    return attachRequestId(
+      createAuthError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 403) {
+    return attachRequestId(
+      createPermissionError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 404) {
+    return attachRequestId(
+      createNotFoundError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 409) {
+    return attachRequestId(
+      createConflictError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  return attachRequestId(
+    createNetworkError(
+      parsed.errorMessage,
+      status,
+      errorDetails,
+      parsed.userMessage,
+      suggestion
+    ),
+    requestId
+  );
+}
+async function httpFetch(url, options) {
+  const {
+    apiUrl,
+    publishableKey,
+    secretKey,
+    customerToken,
+    timeout = DEFAULT_TIMEOUT,
+    debug,
+    retry,
+    onUnauthorized,
+    ...requestInit
+  } = options || {};
+  const baseUrl = resolveApiUrl(apiUrl);
+  const retryConfig = {
+    maxRetries: retry?.maxRetries ?? 3,
+    retryableStatuses: retry?.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES,
+    retryDelay: retry?.retryDelay ?? ((attempt) => Math.min(1e3 * 2 ** attempt, 1e4))
+  };
+  let authToken;
+  if (secretKey) {
+    authToken = secretKey;
+  } else if (customerToken) {
+    authToken = customerToken;
+  }
+  let lastError;
+  let hasRetried401 = false;
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    try {
+      const headers = new Headers(requestInit.headers);
+      if (publishableKey) {
+        headers.set("X-Publishable-Key", publishableKey);
+      }
+      if (authToken) {
+        headers.set("Authorization", `Bearer ${authToken}`);
+      }
+      if (!headers.has("Content-Type") && requestInit.body && !(requestInit.body instanceof FormData)) {
+        headers.set("Content-Type", "application/json");
+      }
+      const redactedHeaders = Object.fromEntries(headers.entries());
+      if (redactedHeaders["authorization"]) {
+        const token = redactedHeaders["authorization"];
+        redactedHeaders["authorization"] = token.length > 20 ? `Bearer ...****${token.slice(-8)}` : "****";
+      }
+      debugLog(debug, "request", url, {
+        method: requestInit.method || "GET",
+        headers: redactedHeaders,
+        attempt: attempt + 1
+      });
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(`${baseUrl}${url}`, {
+        ...requestInit,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      debugLog(debug, "response", url, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries())
+      });
+      if (!response.ok) {
+        if (isUsageLimitExceededResponse(response)) {
+          const limit = parseInt(
+            response.headers.get("X-Usage-Limit") || "0",
+            10
+          );
+          const current = parseInt(
+            response.headers.get("X-Usage-Current") || "0",
+            10
+          );
+          const remaining = parseInt(
+            response.headers.get("X-Usage-Remaining") || "0",
+            10
+          );
+          throw attachRequestId(
+            createUsageLimitError(
+              `Monthly API usage limit exceeded (${current.toLocaleString()}/${limit.toLocaleString()})`,
+              { limit, current, remaining },
+              {
+                url,
+                method: requestInit.method || "GET",
+                attempt: attempt + 1
+              },
+              "Monthly API call limit exceeded. Please upgrade your plan.",
+              "Upgrade your tenant plan to increase the monthly API call limit."
+            ),
+            requestId
+          );
+        }
+        const parsed = await parseErrorBody(response);
+        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && parsed.reason === "token_expired") {
+          hasRetried401 = true;
+          try {
+            const newToken = await onUnauthorized();
+            if (newToken) {
+              authToken = newToken;
+              continue;
+            }
+          } catch {
+          }
+        }
+        const details = {
+          url,
+          method: requestInit.method || "GET",
+          attempt: attempt + 1
+        };
+        if (NON_RETRYABLE_STATUSES.includes(response.status)) {
+          throw createHttpStatusError(
+            response.status,
+            parsed,
+            details,
+            requestId
+          );
+        }
+        const error = attachRequestId(
+          createNetworkError(
+            parsed.errorMessage,
+            response.status,
+            details,
+            parsed.userMessage,
+            getErrorSuggestion(response.status)
+          ),
+          requestId
+        );
+        const method = (requestInit.method || "GET").toUpperCase();
+        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method) && retryConfig.retryableStatuses.includes(response.status)) {
+          lastError = error;
+          const retryDelay = retryConfig.retryDelay(attempt);
+          debugLog(debug, "error", `Retrying in ${retryDelay}ms...`, error);
+          await delay(retryDelay);
+          continue;
+        }
+        throw error;
+      }
+      return response;
+    } catch (error) {
+      debugLog(debug, "error", url, error);
+      const method = (requestInit.method || "GET").toUpperCase();
+      const isSafe = SAFE_METHODS.includes(method);
+      if (error instanceof Error && error.name === "AbortError") {
+        const timeoutError = createTimeoutError(
+          `Request timed out after ${timeout}ms.`,
+          { url, timeout, attempt: attempt + 1 },
+          "The request timed out.",
+          "Please check your network connection or try again later."
+        );
+        if (isSafe && attempt < retryConfig.maxRetries) {
+          lastError = timeoutError;
+          await delay(retryConfig.retryDelay(attempt));
+          continue;
+        }
+        throw timeoutError;
+      }
+      if (error instanceof TypeError) {
+        const networkError = createNetworkError(
+          "Network connection failed.",
+          void 0,
+          { url, originalError: error.message, attempt: attempt + 1 },
+          "Network connection failed.",
+          "Please check your internet connection and try again."
+        );
+        if (isSafe && attempt < retryConfig.maxRetries) {
+          lastError = networkError;
+          await delay(retryConfig.retryDelay(attempt));
+          continue;
+        }
+        throw networkError;
+      }
+      if (error instanceof NetworkError || error instanceof TimeoutError) {
+        if (isSafe && attempt < retryConfig.maxRetries && error.status && !NON_RETRYABLE_STATUSES.includes(error.status) && retryConfig.retryableStatuses.includes(error.status)) {
+          lastError = error;
+          await delay(retryConfig.retryDelay(attempt));
+          continue;
+        }
+        throw error;
+      }
+      if (error instanceof SDKError) {
+        throw error;
+      }
+      const unknownError = createNetworkError(
+        error instanceof Error ? error.message : "An unknown network error occurred.",
+        void 0,
+        { url, originalError: error, attempt: attempt + 1 },
+        "An unknown error occurred.",
+        "Please try again later."
+      );
+      if (isSafe && attempt < retryConfig.maxRetries) {
+        lastError = unknownError;
+        await delay(retryConfig.retryDelay(attempt));
+        continue;
+      }
+      throw unknownError;
+    }
+  }
+  throw lastError ?? new NetworkError("Request failed after retries");
+}
+
+// src/core/collection/http-client.ts
+var HttpClient = class {
+  constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized, onRequestId, apiUrl) {
+    this.publishableKey = requirePublishableKeyForSecret(
+      "CollectionClient",
+      publishableKey,
+      secretKey
+    );
+    this.secretKey = secretKey;
+    this.getCustomerToken = getCustomerToken;
+    this.onUnauthorized = onUnauthorized;
+    this.onRequestId = onRequestId;
+    this.apiUrl = apiUrl;
+  }
+  get defaultOptions() {
+    const opts = {
+      apiUrl: this.apiUrl,
+      publishableKey: this.publishableKey,
+      secretKey: this.secretKey
+    };
+    const token = this.getCustomerToken?.();
+    if (token) {
+      opts.customerToken = token;
+      if (this.onUnauthorized) {
+        opts.onUnauthorized = this.onUnauthorized;
+      }
+    }
+    return opts;
+  }
+  async fetchWithTracking(url, opts) {
+    try {
+      const response = await httpFetch(url, opts);
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return response;
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
+  buildUrl(endpoint, options) {
+    if (!options) return endpoint;
+    const queryString = stringify(options, { addQueryPrefix: true });
+    return queryString ? `${endpoint}${queryString}` : endpoint;
+  }
+  assertJsonResponse(response) {
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      throw createApiError("Response is not in JSON format.", response.status, {
+        contentType
+      });
+    }
+  }
+  /**
+   * Parse Payload CMS find response (list query)
+   * Returns native Payload response structure
+   */
+  async parseFindResponse(response) {
+    const contentType = response.headers.get("content-type");
+    try {
+      this.assertJsonResponse(response);
+      const jsonData = await response.json();
+      if (jsonData.docs === void 0) {
+        throw createApiError("Invalid find response.", response.status, {
+          jsonData
+        });
+      }
+      return {
+        docs: jsonData.docs,
+        totalDocs: jsonData.totalDocs ?? 0,
+        limit: jsonData.limit || 20,
+        totalPages: jsonData.totalPages ?? 0,
+        page: jsonData.page || 1,
+        pagingCounter: jsonData.pagingCounter || 1,
+        hasPrevPage: jsonData.hasPrevPage ?? false,
+        hasNextPage: jsonData.hasNextPage ?? false,
+        prevPage: jsonData.prevPage ?? null,
+        nextPage: jsonData.nextPage ?? null
+      };
+    } catch (error) {
+      if (error instanceof SDKError) throw error;
+      throw createApiError("Failed to parse response.", response.status, {
+        contentType,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+  /**
+   * Parse Payload CMS mutation response (create/update)
+   * Returns native Payload response structure
+   */
+  async parseMutationResponse(response) {
+    const contentType = response.headers.get("content-type");
+    try {
+      this.assertJsonResponse(response);
+      const jsonData = await response.json();
+      if (jsonData.doc === void 0) {
+        throw createApiError("Invalid mutation response.", response.status, {
+          jsonData
+        });
+      }
+      return {
+        message: jsonData.message || "",
+        doc: jsonData.doc,
+        errors: jsonData.errors
+      };
+    } catch (error) {
+      if (error instanceof SDKError) throw error;
+      throw createApiError("Failed to parse response.", response.status, {
+        contentType,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+  /**
+   * Parse Payload CMS document response (findById/delete)
+   * Returns document directly without wrapper
+   */
+  async parseDocumentResponse(response) {
+    const contentType = response.headers.get("content-type");
+    try {
+      this.assertJsonResponse(response);
+      const jsonData = await response.json();
+      return jsonData;
+    } catch (error) {
+      if (error instanceof SDKError) throw error;
+      throw createApiError("Failed to parse response.", response.status, {
+        contentType,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+};
+
+// src/core/collection/collection-client.ts
+function buildPayloadFormData(data, file, filename) {
+  const formData = new FormData();
+  formData.append("file", file, filename);
+  if (data != null) {
+    formData.append("_payload", JSON.stringify(data));
+  }
+  return formData;
+}
+var CollectionClient = class extends HttpClient {
+  from(collection) {
+    return new CollectionQueryBuilder(this, collection);
+  }
+  // ============================================================================
+  // Payload-native methods
+  // ============================================================================
+  /**
+   * Find documents (list query)
+   * GET /api/{collection}
+   */
+  async requestFind(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
+    const response = await this.fetchWithTracking(url, {
+      ...this.defaultOptions,
+      method: "GET"
+    });
+    return this.parseFindResponse(response);
+  }
+  /**
+   * Find-like response from a custom endpoint
+   * POST /api/...custom-endpoint
+   */
+  async requestFindEndpoint(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "POST",
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return this.parseFindResponse(response);
+  }
+  /**
+   * Find document by ID
+   * GET /api/{collection}/{id}
+   */
+  async requestFindById(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
+    const response = await this.fetchWithTracking(url, {
+      ...this.defaultOptions,
+      method: "GET"
+    });
+    return this.parseDocumentResponse(response);
+  }
+  /**
+   * Create document
+   * POST /api/{collection}
+   */
+  async requestCreate(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "POST",
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return this.parseMutationResponse(response);
+  }
+  /**
+   * Update document
+   * PATCH /api/{collection}/{id}
+   */
+  async requestUpdate(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "PATCH",
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return this.parseMutationResponse(response);
+  }
+  /**
+   * Count documents
+   * GET /api/{collection}/count
+   */
+  async requestCount(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
+    const response = await this.fetchWithTracking(url, {
+      ...this.defaultOptions,
+      method: "GET"
+    });
+    return this.parseDocumentResponse(response);
+  }
+  /**
+   * Update multiple documents (bulk update)
+   * PATCH /api/{collection}
+   */
+  async requestUpdateMany(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return this.parseFindResponse(response);
+  }
+  /**
+   * Delete document
+   * DELETE /api/{collection}/{id}
+   */
+  async requestDelete(endpoint) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "DELETE"
+    });
+    return this.parseDocumentResponse(response);
+  }
+  /**
+   * Delete multiple documents (bulk delete)
+   * DELETE /api/{collection}
+   */
+  async requestDeleteMany(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "DELETE",
+      body: JSON.stringify(data)
+    });
+    return this.parseFindResponse(response);
+  }
+  /**
+   * Create document with file upload
+   * POST /api/{collection} (multipart/form-data)
+   */
+  async requestCreateWithFile(endpoint, data, file, filename) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "POST",
+      body: buildPayloadFormData(data, file, filename)
+    });
+    return this.parseMutationResponse(response);
+  }
+  /**
+   * Update document with file upload
+   * PATCH /api/{collection}/{id} (multipart/form-data)
+   */
+  async requestUpdateWithFile(endpoint, data, file, filename) {
+    const response = await this.fetchWithTracking(endpoint, {
+      ...this.defaultOptions,
+      method: "PATCH",
+      body: buildPayloadFormData(data, file, filename)
+    });
+    return this.parseMutationResponse(response);
+  }
+};
+
+// src/core/query/query-client.ts
+function createReadOnlyQueryHooksFacade(hooks) {
+  return {
+    useQuery: hooks.useQuery.bind(hooks),
+    useSuspenseQuery: hooks.useSuspenseQuery.bind(hooks),
+    useQueryById: hooks.useQueryById.bind(hooks),
+    useSuspenseQueryById: hooks.useSuspenseQueryById.bind(hooks),
+    useInfiniteQuery: hooks.useInfiniteQuery.bind(hooks),
+    useSuspenseInfiniteQuery: hooks.useSuspenseInfiniteQuery.bind(hooks),
+    prefetchQuery: hooks.prefetchQuery.bind(hooks),
+    prefetchQueryById: hooks.prefetchQueryById.bind(hooks),
+    prefetchInfiniteQuery: hooks.prefetchInfiniteQuery.bind(hooks),
+    invalidateQueries: hooks.invalidateQueries.bind(hooks),
+    getQueryData: hooks.getQueryData.bind(hooks),
+    setQueryData: hooks.setQueryData.bind(hooks),
+    useCustomerMe: hooks.useCustomerMe.bind(hooks),
+    useCustomerLogin: hooks.useCustomerLogin.bind(hooks),
+    useCustomerRegister: hooks.useCustomerRegister.bind(hooks),
+    useCustomerLogout: hooks.useCustomerLogout.bind(hooks),
+    useCustomerForgotPassword: hooks.useCustomerForgotPassword.bind(hooks),
+    useCustomerResetPassword: hooks.useCustomerResetPassword.bind(hooks),
+    useCustomerRefreshToken: hooks.useCustomerRefreshToken.bind(hooks),
+    useCustomerUpdateProfile: hooks.useCustomerUpdateProfile.bind(hooks),
+    useCustomerChangePassword: hooks.useCustomerChangePassword.bind(hooks),
+    invalidateCustomerQueries: hooks.invalidateCustomerQueries.bind(hooks),
+    getCustomerData: hooks.getCustomerData.bind(hooks),
+    setCustomerData: hooks.setCustomerData.bind(hooks),
+    useProductListingGroupsQuery: hooks.useProductListingGroupsQuery.bind(hooks),
+    useSuspenseProductListingGroupsQuery: hooks.useSuspenseProductListingGroupsQuery.bind(hooks),
+    useInfiniteProductListingGroupsQuery: hooks.useInfiniteProductListingGroupsQuery.bind(hooks),
+    useSuspenseInfiniteProductListingGroupsQuery: hooks.useSuspenseInfiniteProductListingGroupsQuery.bind(hooks),
+    prefetchProductListingGroupsQuery: hooks.prefetchProductListingGroupsQuery.bind(hooks),
+    prefetchInfiniteProductListingGroupsQuery: hooks.prefetchInfiniteProductListingGroupsQuery.bind(hooks),
+    useProductDetail: hooks.useProductDetail.bind(hooks),
+    useProductDetailBySlug: hooks.useProductDetailBySlug.bind(hooks),
+    useProductDetailById: hooks.useProductDetailById.bind(hooks)
+  };
+}
+function createQueryHooks(client, queryClient = getQueryClient()) {
+  const config = client.getConfig();
+  const onUnauthorized = async () => {
+    try {
+      const result = await client.customer.auth.refreshToken();
+      return result.token ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const collectionClient = new CollectionClient(
+    config.publishableKey,
+    void 0,
+    () => client.customer.auth.getToken(),
+    onUnauthorized,
+    (id) => {
+      client.lastRequestId = id;
+    },
+    config.apiUrl
+  );
+  const hooks = new QueryHooks(
+    queryClient,
+    collectionClient,
+    client.customer.auth,
+    client.commerce
+  );
+  return createReadOnlyQueryHooksFacade(hooks);
+}
+function createServerQueryHooks(client, queryClient = getQueryClient()) {
+  return new QueryHooks(
+    queryClient,
+    client.collections,
+    void 0,
+    client.commerce
+  );
+}
+export {
+  CollectionHooks,
+  CustomerHooks,
+  QueryHooks,
+  RealtimeConnection,
+  collectionKeys,
+  createQueryHooks,
+  createServerQueryHooks,
+  customerKeys,
+  getQueryClient,
+  productKeys
+};
+//# sourceMappingURL=query.js.map