@codesocietyou/contentedge-cms-sdk 1.0.1 → 1.0.3

package/dist/index.d.cts

@@ -0,0 +1,1682 @@
+import { AxiosInstance } from "axios";
+import * as _$_tanstack_react_query0 from "@tanstack/react-query";
+import { UseQueryResult } from "@tanstack/react-query";
+
+//#region src/types/config.d.ts
+interface SdkConfig {
+  baseUrl: string;
+  fileBaseUrl?: string;
+  apiKey?: string;
+  tenant?: string;
+  timeoutMs?: number;
+  logger?: {
+    debug?: (...args: unknown[]) => void;
+    warn?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+  };
+}
+//#endregion
+//#region src/services/apiClient.d.ts
+/**
+ * Create and configure the API client with the given configuration
+ */
+declare function createApiClient(config: SdkConfig): AxiosInstance;
+/**
+ * Get the current API client instance
+ * Throws if not initialized
+ */
+declare function getApiClient(): AxiosInstance;
+/**
+ * Reset the API client (useful for testing)
+ */
+declare function resetApiClient(): void;
+declare const apiClient: AxiosInstance;
+//#endregion
+//#region src/types/content.d.ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type CustomFields = Record<string, JsonValue>;
+interface ContentDto<C extends CustomFields = CustomFields> {
+  id: number;
+  title: string;
+  text: string;
+  type: string;
+  customFields: C;
+}
+interface ApiResponse<T> {
+  status: 'SUCCESS' | 'FAILURE';
+  message: string;
+  data: T;
+}
+interface PaginatedData<T> {
+  content: T[];
+  number?: number;
+  size?: number;
+  numberOfElements?: number;
+  totalElements?: number;
+  totalPages?: number;
+  first?: boolean;
+  last?: boolean;
+  empty?: boolean;
+  sort?: unknown;
+  pageable?: unknown;
+}
+type ContentResponse<C extends CustomFields = CustomFields> = ApiResponse<PaginatedData<ContentDto<C>>>;
+interface ContentListParams {
+  type?: string;
+  page?: number;
+  size?: number;
+  sortBy?: string;
+  direction?: 'ASC' | 'DESC';
+  filters?: Record<string, string | number | boolean | null | undefined>;
+}
+/**
+ * Normalized content item with commonly used fields.
+ * This type is exported for convenience but normalization is handled
+ * by the {@link normalizeContentItem} function in utils/normalization.
+ */
+interface NormalizedContentItem {
+  id: number;
+  title: string;
+  /**
+   * Main body text for the content item.
+   *
+   * This field may contain **TipTap-generated HTML** (e.g. `<p>`, `<ul>`, `<li>`,
+   * `<strong>`, `<em>`, `<a>`). Render it with a rich text renderer (TipTap
+   * read-only mode or `dangerouslySetInnerHTML`) rather than as a plain string.
+   * Use {@link stripHtmlTags} to obtain a plain-text preview.
+   */
+  text: string;
+  type: string;
+  insideImage: string;
+  outsideImage: string;
+  pdfPath: string | null;
+  /**
+   * References / bibliography field.
+   *
+   * May contain **TipTap-generated HTML** (ordered lists, links, bold text).
+   * Render with a rich text renderer or strip with {@link stripHtmlTags}.
+   */
+  references: string | null;
+  citation: string | null;
+  /**
+   * Abstract or summary of the content item.
+   *
+   * May contain **TipTap-generated HTML** (paragraphs, bold, italic).
+   * Render with a rich text renderer or strip with {@link stripHtmlTags}.
+   */
+  abstract: string | null;
+  team: string | null;
+  publicationType: string | null;
+  fake: boolean | null;
+}
+//#endregion
+//#region src/services/contentApi.d.ts
+/**
+ * Fetch content by type with pagination and filters
+ */
+declare function fetchContentByType<C extends CustomFields = CustomFields>(params?: ContentListParams): Promise<ContentResponse<C>>;
+/**
+ * Fetch a single content item by ID
+ */
+declare function fetchContentById<C extends CustomFields = CustomFields>(id: number): Promise<ApiResponse<ContentDto<C>>>;
+/**
+ * Download a file from a given path
+ * @param path - Full URL or relative path to the file
+ * @returns Blob containing the file data
+ */
+declare function downloadFile(path: string): Promise<Blob>;
+//#endregion
+//#region src/services/contentFetchAll.d.ts
+interface FetchAllOptions<C extends CustomFields, T> {
+  /**
+   * Optional function to transform each content item
+   */
+  mapItem?: (item: ContentDto<C>) => T;
+  /**
+   * Optional function to extract a unique key for deduplication
+   */
+  dedupeBy?: (item: T) => string | number;
+  /**
+   * Maximum number of pages to fetch (safety limit)
+   * @default 20
+   */
+  hardStopMaxPages?: number;
+}
+/**
+ * Fetch all content items across multiple pages with automatic pagination
+ *
+ * This function will continue fetching pages until:
+ * - No more items are returned
+ * - The last page is reached (based on pagination metadata)
+ * - The hard stop limit is reached
+ * - No new items are added (all items are duplicates)
+ *
+ * @param params - Content list parameters (without page number)
+ * @param options - Fetch options including mapping and deduplication
+ * @returns Array of all fetched items
+ */
+declare function fetchAllContent<C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, 'page'> & {
+  page?: never;
+}, options?: FetchAllOptions<C, T>): Promise<T[]>;
+//#endregion
+//#region node_modules/@tanstack/query-core/build/modern/_tsup-dts-rollup.d.ts
+declare type Action<TData, TError, TVariables, TOnMutateResult> = ContinueAction_2 | ErrorAction_2<TError> | FailedAction_2<TError> | PendingAction<TVariables, TOnMutateResult> | PauseAction_2 | SuccessAction_2<TData>;
+declare type Action_alias_1<TData, TError> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | FetchAction | InvalidateAction | PauseAction | SetStateAction<TData, TError> | SuccessAction<TData>;
+declare type AnyDataTag = {
+  [dataTagSymbol$1]: any;
+  [dataTagErrorSymbol$1]: any;
+};
+declare interface CancelOptions {
+  revert?: boolean;
+  silent?: boolean;
+}
+declare interface ContinueAction {
+  type: 'continue';
+}
+declare interface ContinueAction_2 {
+  type: 'continue';
+}
+declare type DataTag<TType, TValue, TError = UnsetMarker> = TType extends AnyDataTag ? TType : TType & {
+  [dataTagSymbol$1]: TValue;
+  [dataTagErrorSymbol$1]: TError;
+};
+declare const dataTagErrorSymbol$1: unique symbol;
+declare type dataTagErrorSymbol$1 = typeof dataTagErrorSymbol$1;
+declare const dataTagSymbol$1: unique symbol;
+declare type dataTagSymbol$1 = typeof dataTagSymbol$1;
+declare type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwOnError' | 'refetchOnReconnect' | 'queryHash'>;
+declare type DefaultError = Register extends {
+  defaultError: infer TError;
+} ? TError : Error;
+declare interface DefaultOptions<TError = DefaultError> {
+  queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'suspense' | 'queryKey'>;
+  mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
+  hydrate?: HydrateOptions['defaultOptions'];
+  dehydrate?: DehydrateOptions;
+}
+declare type DefinedInfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
+declare type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
+declare interface DehydrateOptions {
+  serializeData?: TransformerFn;
+  shouldDehydrateMutation?: (mutation: Mutation) => boolean;
+  shouldDehydrateQuery?: (query: Query) => boolean;
+  shouldRedactErrors?: (error: unknown) => boolean;
+}
+declare type DropLast<T extends ReadonlyArray<unknown>> = T extends readonly [...infer R, unknown] ? readonly [...R] : never;
+declare type EnsureInfiniteQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+  revalidateIfStale?: boolean;
+};
+declare interface EnsureQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> {
+  revalidateIfStale?: boolean;
+}
+declare interface ErrorAction<TError> {
+  type: 'error';
+  error: TError;
+}
+declare interface ErrorAction_2<TError> {
+  type: 'error';
+  error: TError;
+}
+declare interface FailedAction<TError> {
+  type: 'failed';
+  failureCount: number;
+  error: TError;
+}
+declare interface FailedAction_2<TError> {
+  type: 'failed';
+  failureCount: number;
+  error: TError | null;
+}
+declare interface FetchAction {
+  type: 'fetch';
+  meta?: FetchMeta;
+}
+declare interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+  fetchFn: () => unknown | Promise<unknown>;
+  fetchOptions?: FetchOptions;
+  signal: AbortSignal;
+  options: QueryOptions<TQueryFnData, TError, TData, any>;
+  client: QueryClient;
+  queryKey: TQueryKey;
+  state: QueryState<TData, TError>;
+}
+declare type FetchDirection = 'forward' | 'backward';
+declare type FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Omit<FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData, TPageParam>, TQueryKey, TPageParam>, 'initialPageParam'> & InitialPageParam<TPageParam> & FetchInfiniteQueryPages<TQueryFnData, TPageParam>;
+declare type FetchInfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> = {
+  pages?: never;
+} | {
+  pages: number;
+  getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
+};
+declare interface FetchMeta {
+  fetchMore?: {
+    direction: FetchDirection;
+  };
+}
+declare interface FetchNextPageOptions extends ResultOptions {
+  /**
+   * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,
+   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
+   *
+   * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.
+   *
+   * Defaults to `true`.
+   */
+  cancelRefetch?: boolean;
+}
+declare interface FetchOptions<TData = unknown> {
+  cancelRefetch?: boolean;
+  meta?: FetchMeta;
+  initialPromise?: Promise<TData>;
+}
+declare interface FetchPreviousPageOptions extends ResultOptions {
+  /**
+   * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,
+   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
+   *
+   * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.
+   *
+   * Defaults to `true`.
+   */
+  cancelRefetch?: boolean;
+}
+declare interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'> {
+  initialPageParam?: never;
+  /**
+   * The time in milliseconds after data is considered stale.
+   * If the data is fresh it will be returned from the cache.
+   */
+  staleTime?: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>;
+}
+declare type FetchStatus = 'fetching' | 'paused' | 'idle';
+declare type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: Array<TQueryFnData>, lastPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
+declare interface HydrateOptions {
+  defaultOptions?: {
+    deserializeData?: TransformerFn;
+    queries?: QueryOptions;
+    mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>;
+  };
+}
+declare type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown> ? TaggedValue : TQueryFnData;
+declare type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError> ? TaggedError extends UnsetMarker ? TError : TaggedError : TError;
+declare interface InfiniteData<TData, TPageParam = unknown> {
+  pages: Array<TData>;
+  pageParams: Array<TPageParam>;
+}
+declare interface InfiniteQueryObserverBaseResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  /**
+   * This function allows you to fetch the next "page" of results.
+   */
+  fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+  /**
+   * This function allows you to fetch the previous "page" of results.
+   */
+  fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+  /**
+   * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
+   */
+  hasNextPage: boolean;
+  /**
+   * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
+   */
+  hasPreviousPage: boolean;
+  /**
+   * Will be `true` if the query failed while fetching the next page.
+   */
+  isFetchNextPageError: boolean;
+  /**
+   * Will be `true` while fetching the next page with `fetchNextPage`.
+   */
+  isFetchingNextPage: boolean;
+  /**
+   * Will be `true` if the query failed while fetching the previous page.
+   */
+  isFetchPreviousPageError: boolean;
+  /**
+   * Will be `true` while fetching the previous page with `fetchPreviousPage`.
+   */
+  isFetchingPreviousPage: boolean;
+}
+declare interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+declare interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+declare interface InfiniteQueryObserverPendingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+declare interface InfiniteQueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: TData;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  status: 'success';
+}
+declare interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+declare type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError> | InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverPendingResult<TData, TError> | InfiniteQueryObserverPlaceholderResult<TData, TError>;
+declare interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isFetchNextPageError: false;
+  isFetchPreviousPageError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: 'success';
+}
+declare type InitialDataFunction<T> = () => T | undefined;
+declare interface InitialPageParam<TPageParam = unknown> {
+  initialPageParam: TPageParam;
+}
+declare interface InvalidateAction {
+  type: 'invalidate';
+}
+declare interface InvalidateOptions extends RefetchOptions {}
+declare interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {
+  refetchType?: QueryTypeFilter | 'none';
+}
+declare type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>) => Promise<TData>;
+declare interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
+  onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+  onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
+}
+declare class Mutation<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> extends Removable {
+  #private;
+  state: MutationState<TData, TError, TVariables, TOnMutateResult>;
+  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  readonly mutationId: number;
+  constructor(config: MutationConfig<TData, TError, TVariables, TOnMutateResult>);
+  setOptions(options: MutationOptions<TData, TError, TVariables, TOnMutateResult>): void;
+  get meta(): MutationMeta | undefined;
+  addObserver(observer: MutationObserver_2<any, any, any, any>): void;
+  removeObserver(observer: MutationObserver_2<any, any, any, any>): void;
+  protected optionalRemove(): void;
+  continue(): Promise<unknown>;
+  execute(variables: TVariables): Promise<TData>;
+}
+declare class MutationCache extends Subscribable<MutationCacheListener> {
+  #private;
+  config: MutationCacheConfig;
+  constructor(config?: MutationCacheConfig);
+  build<TData, TError, TVariables, TOnMutateResult>(client: QueryClient, options: MutationOptions<TData, TError, TVariables, TOnMutateResult>, state?: MutationState<TData, TError, TVariables, TOnMutateResult>): Mutation<TData, TError, TVariables, TOnMutateResult>;
+  add(mutation: Mutation<any, any, any, any>): void;
+  remove(mutation: Mutation<any, any, any, any>): void;
+  canRun(mutation: Mutation<any, any, any, any>): boolean;
+  runNext(mutation: Mutation<any, any, any, any>): Promise<unknown>;
+  clear(): void;
+  getAll(): Array<Mutation>;
+  find<TData = unknown, TError = DefaultError, TVariables = any, TOnMutateResult = unknown>(filters: MutationFilters): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined;
+  findAll(filters?: MutationFilters): Array<Mutation>;
+  notify(event: MutationCacheNotifyEvent): void;
+  resumePausedMutations(): Promise<unknown>;
+}
+declare interface MutationCacheConfig {
+  onError?: (error: DefaultError, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onSuccess?: (data: unknown, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onSettled?: (data: unknown | undefined, error: DefaultError | null, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
+}
+declare type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;
+declare type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationObserverOptionsUpdated | NotifyEventMutationUpdated;
+declare interface MutationConfig<TData, TError, TVariables, TOnMutateResult> {
+  client: QueryClient;
+  mutationId: number;
+  mutationCache: MutationCache;
+  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  state?: MutationState<TData, TError, TVariables, TOnMutateResult>;
+}
+declare interface MutationFilters<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
+  /**
+   * Match mutation key exactly
+   */
+  exact?: boolean;
+  /**
+   * Include mutations matching this predicate function
+   */
+  predicate?: (mutation: Mutation<TData, TError, TVariables, TOnMutateResult>) => boolean;
+  /**
+   * Include mutations matching this mutation key
+   */
+  mutationKey?: TuplePrefixes<MutationKey>;
+  /**
+   * Filter by mutation status
+   */
+  status?: MutationStatus;
+}
+declare type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables, context: MutationFunctionContext) => Promise<TData>;
+declare type MutationFunctionContext = {
+  client: QueryClient;
+  meta: MutationMeta | undefined;
+  mutationKey?: MutationKey;
+};
+declare type MutationKey = Register extends {
+  mutationKey: infer TMutationKey;
+} ? TMutationKey extends ReadonlyArray<unknown> ? TMutationKey : TMutationKey extends Array<unknown> ? TMutationKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+declare type MutationMeta = Register extends {
+  mutationMeta: infer TMutationMeta;
+} ? TMutationMeta extends Record<string, unknown> ? TMutationMeta : Record<string, unknown> : Record<string, unknown>;
+declare class MutationObserver_2<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends Subscribable<MutationObserverListener<TData, TError, TVariables, TOnMutateResult>> {
+  #private;
+  options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
+  constructor(client: QueryClient, options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>);
+  protected bindMethods(): void;
+  setOptions(options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>): void;
+  protected onUnsubscribe(): void;
+  onMutationUpdate(action: Action<TData, TError, TVariables, TOnMutateResult>): void;
+  getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TOnMutateResult>;
+  reset(): void;
+  mutate(variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>): Promise<TData>;
+}
+declare interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationState<TData, TError, TVariables, TOnMutateResult> {
+  /**
+   * The last successfully resolved data for the mutation.
+   */
+  data: TData | undefined;
+  /**
+   * The variables object passed to the `mutationFn`.
+   */
+  variables: TVariables | undefined;
+  /**
+   * The error object for the mutation, if an error was encountered.
+   * - Defaults to `null`.
+   */
+  error: TError | null;
+  /**
+   * A boolean variable derived from `status`.
+   * - `true` if the last mutation attempt resulted in an error.
+   */
+  isError: boolean;
+  /**
+   * A boolean variable derived from `status`.
+   * - `true` if the mutation is in its initial state prior to executing.
+   */
+  isIdle: boolean;
+  /**
+   * A boolean variable derived from `status`.
+   * - `true` if the mutation is currently executing.
+   */
+  isPending: boolean;
+  /**
+   * A boolean variable derived from `status`.
+   * - `true` if the last mutation attempt was successful.
+   */
+  isSuccess: boolean;
+  /**
+   * The status of the mutation.
+   * - Will be:
+   *   - `idle` initial status prior to the mutation function executing.
+   *   - `pending` if the mutation is currently executing.
+   *   - `error` if the last mutation attempt resulted in an error.
+   *   - `success` if the last mutation attempt was successful.
+   */
+  status: MutationStatus;
+  /**
+   * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
+   * @param variables - The variables object to pass to the `mutationFn`.
+   * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.
+   * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.
+   * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
+   * @remarks
+   * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
+   * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
+   */
+  mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+  /**
+   * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
+   */
+  reset: () => void;
+}
+declare interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
+  data: undefined;
+  error: TError;
+  variables: TVariables;
+  isError: true;
+  isIdle: false;
+  isPending: false;
+  isSuccess: false;
+  status: 'error';
+}
+declare interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
+  data: undefined;
+  variables: undefined;
+  error: null;
+  isError: false;
+  isIdle: true;
+  isPending: false;
+  isSuccess: false;
+  status: 'idle';
+}
+declare type MutationObserverListener<TData, TError, TVariables, TOnMutateResult> = (result: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>) => void;
+declare interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
+  data: undefined;
+  variables: TVariables;
+  error: null;
+  isError: false;
+  isIdle: false;
+  isPending: true;
+  isSuccess: false;
+  status: 'pending';
+}
+declare interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {
+  throwOnError?: boolean | ((error: TError) => boolean);
+}
+declare type MutationObserverResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverLoadingResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverErrorResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverSuccessResult<TData, TError, TVariables, TOnMutateResult>;
+declare interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
+  data: TData;
+  error: null;
+  variables: TVariables;
+  isError: false;
+  isIdle: false;
+  isPending: false;
+  isSuccess: true;
+  status: 'success';
+}
+declare interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
+  mutationFn?: MutationFunction<TData, TVariables>;
+  mutationKey?: MutationKey;
+  onMutate?: (variables: TVariables, context: MutationFunctionContext) => Promise<TOnMutateResult> | TOnMutateResult;
+  onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
+  retry?: RetryValue<TError>;
+  retryDelay?: RetryDelayValue<TError>;
+  networkMode?: NetworkMode;
+  gcTime?: number;
+  _defaulted?: boolean;
+  meta?: MutationMeta;
+  scope?: MutationScope;
+}
+declare type MutationScope = {
+  id: string;
+};
+declare interface MutationState<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
+  context: TOnMutateResult | undefined;
+  data: TData | undefined;
+  error: TError | null;
+  failureCount: number;
+  failureReason: TError | null;
+  isPaused: boolean;
+  status: MutationStatus;
+  variables: TVariables | undefined;
+  submittedAt: number;
+}
+declare type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+declare type NetworkMode = 'online' | 'always' | 'offlineFirst';
+declare type NoInfer_2<T> = [T][T extends any ? 0 : never];
+declare type NonFunctionGuard<T> = T extends Function ? never : T;
+declare interface NotifyEvent {
+  type: NotifyEventType;
+}
+declare interface NotifyEventMutationAdded extends NotifyEvent {
+  type: 'added';
+  mutation: Mutation<any, any, any, any>;
+}
+declare interface NotifyEventMutationObserverAdded extends NotifyEvent {
+  type: 'observerAdded';
+  mutation: Mutation<any, any, any, any>;
+  observer: MutationObserver_2<any, any, any>;
+}
+declare interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
+  type: 'observerOptionsUpdated';
+  mutation?: Mutation<any, any, any, any>;
+  observer: MutationObserver_2<any, any, any, any>;
+}
+declare interface NotifyEventMutationObserverRemoved extends NotifyEvent {
+  type: 'observerRemoved';
+  mutation: Mutation<any, any, any, any>;
+  observer: MutationObserver_2<any, any, any>;
+}
+declare interface NotifyEventMutationRemoved extends NotifyEvent {
+  type: 'removed';
+  mutation: Mutation<any, any, any, any>;
+}
+declare interface NotifyEventMutationUpdated extends NotifyEvent {
+  type: 'updated';
+  mutation: Mutation<any, any, any, any>;
+  action: Action<any, any, any, any>;
+}
+declare interface NotifyEventQueryAdded extends NotifyEvent {
+  type: 'added';
+  query: Query<any, any, any, any>;
+}
+declare interface NotifyEventQueryObserverAdded extends NotifyEvent {
+  type: 'observerAdded';
+  query: Query<any, any, any, any>;
+  observer: QueryObserver<any, any, any, any, any>;
+}
+declare interface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {
+  type: 'observerOptionsUpdated';
+  query: Query<any, any, any, any>;
+  observer: QueryObserver<any, any, any, any, any>;
+}
+declare interface NotifyEventQueryObserverRemoved extends NotifyEvent {
+  type: 'observerRemoved';
+  query: Query<any, any, any, any>;
+  observer: QueryObserver<any, any, any, any, any>;
+}
+declare interface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {
+  type: 'observerResultsUpdated';
+  query: Query<any, any, any, any>;
+}
+declare interface NotifyEventQueryRemoved extends NotifyEvent {
+  type: 'removed';
+  query: Query<any, any, any, any>;
+}
+declare interface NotifyEventQueryUpdated extends NotifyEvent {
+  type: 'updated';
+  query: Query<any, any, any, any>;
+  action: Action_alias_1<any, any>;
+}
+declare type NotifyEventType = 'added' | 'removed' | 'updated' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
+declare type NotifyOnChangeProps = Array<keyof InfiniteQueryObserverResult> | 'all' | undefined | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined);
+declare interface ObserverFetchOptions extends FetchOptions {
+  throwOnError?: boolean;
+}
+declare type OmitKeyof<TObject, TKey extends (TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject), TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
+declare interface PauseAction {
+  type: 'pause';
+}
+declare interface PauseAction_2 {
+  type: 'pause';
+}
+declare interface PendingAction<TVariables, TOnMutateResult> {
+  type: 'pending';
+  isPaused: boolean;
+  variables?: TVariables;
+  context?: TOnMutateResult;
+}
+declare type PlaceholderDataFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (previousData: TQueryData | undefined, previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => TQueryData | undefined;
+declare class Query<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Removable {
+  #private;
+  queryKey: TQueryKey;
+  queryHash: string;
+  options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+  state: QueryState<TData, TError>;
+  observers: Array<QueryObserver<any, any, any, any, any>>;
+  constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);
+  get meta(): QueryMeta | undefined;
+  get queryType(): "infinite" | undefined;
+  get promise(): Promise<TData> | undefined;
+  setOptions(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): void;
+  protected optionalRemove(): void;
+  setData(newData: TData, options?: SetDataOptions & {
+    manual: boolean;
+  }): TData;
+  setState(state: Partial<QueryState<TData, TError>>): void;
+  cancel(options?: CancelOptions): Promise<void>;
+  destroy(): void;
+  get resetState(): QueryState<TData, TError>;
+  reset(): void;
+  isActive(): boolean;
+  isDisabled(): boolean;
+  isFetched(): boolean;
+  isStatic(): boolean;
+  isStale(): boolean;
+  isStaleByTime(staleTime?: StaleTime): boolean;
+  onFocus(): void;
+  onOnline(): void;
+  addObserver(observer: QueryObserver<any, any, any, any, any>): void;
+  removeObserver(observer: QueryObserver<any, any, any, any, any>): void;
+  getObserversCount(): number;
+  invalidate(): void;
+  fetch(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, fetchOptions?: FetchOptions<TQueryFnData>): Promise<TData>;
+}
+declare interface QueryBehavior<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+  onFetch: (context: FetchContext<TQueryFnData, TError, TData, TQueryKey>, query: Query) => void;
+}
+declare type QueryBooleanOption<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = boolean | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean);
+declare class QueryCache extends Subscribable<QueryCacheListener> {
+  #private;
+  config: QueryCacheConfig;
+  constructor(config?: QueryCacheConfig);
+  build<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(client: QueryClient, options: WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>, state?: QueryState<TData, TError>): Query<TQueryFnData, TError, TData, TQueryKey>;
+  add(query: Query<any, any, any, any>): void;
+  remove(query: Query<any, any, any, any>): void;
+  clear(): void;
+  get<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryHash: string): Query<TQueryFnData, TError, TData, TQueryKey> | undefined;
+  getAll(): Array<Query>;
+  find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: WithRequired<QueryFilters, 'queryKey'>): Query<TQueryFnData, TError, TData> | undefined;
+  findAll(filters?: QueryFilters<any>): Array<Query>;
+  notify(event: QueryCacheNotifyEvent): void;
+  onFocus(): void;
+  onOnline(): void;
+}
+declare interface QueryCacheConfig {
+  onError?: (error: DefaultError, query: Query<unknown, unknown, unknown>) => void;
+  onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
+  onSettled?: (data: unknown | undefined, error: DefaultError | null, query: Query<unknown, unknown, unknown>) => void;
+}
+declare type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
+declare type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated | NotifyEventQueryObserverOptionsUpdated;
+declare class QueryClient {
+  #private;
+  constructor(config?: QueryClientConfig);
+  mount(): void;
+  unmount(): void;
+  isFetching<TQueryFilters extends QueryFilters<any> = QueryFilters>(filters?: TQueryFilters): number;
+  isMutating<TMutationFilters extends MutationFilters<any, any> = MutationFilters>(filters?: TMutationFilters): number;
+  /**
+   * Imperative (non-reactive) way to retrieve data for a QueryKey.
+   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+   *
+   * Hint: Do not use this function inside a component, because it won't receive updates.
+   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+   */
+  getQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined;
+  ensureQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+  getQueriesData<TQueryFnData = unknown, TQueryFilters extends QueryFilters<any> = QueryFilters>(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]>;
+  setQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>>(queryKey: TTaggedQueryKey, updater: Updater<NoInfer_2<TInferredQueryFnData> | undefined, NoInfer_2<TInferredQueryFnData> | undefined>, options?: SetDataOptions): NoInfer_2<TInferredQueryFnData> | undefined;
+  setQueriesData<TQueryFnData, TQueryFilters extends QueryFilters<any> = QueryFilters>(filters: TQueryFilters, updater: Updater<NoInfer_2<TQueryFnData> | undefined, NoInfer_2<TQueryFnData> | undefined>, options?: SetDataOptions): Array<[QueryKey, TQueryFnData | undefined]>;
+  getQueryState<TQueryFnData = unknown, TError = DefaultError, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>, TInferredError = InferErrorFromTag<TError, TTaggedQueryKey>>(queryKey: TTaggedQueryKey): QueryState<TInferredQueryFnData, TInferredError> | undefined;
+  removeQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: QueryFilters<TTaggedQueryKey>): void;
+  resetQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: QueryFilters<TTaggedQueryKey>, options?: ResetOptions): Promise<void>;
+  cancelQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: QueryFilters<TTaggedQueryKey>, cancelOptions?: CancelOptions): Promise<void>;
+  invalidateQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: InvalidateQueryFilters<TTaggedQueryKey>, options?: InvalidateOptions): Promise<void>;
+  refetchQueries<TTaggedQueryKey extends QueryKey = QueryKey>(filters?: RefetchQueryFilters<TTaggedQueryKey>, options?: RefetchOptions): Promise<void>;
+  fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
+  prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+  fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
+  prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
+  ensureInfiniteQueryData<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: EnsureInfiniteQueryDataOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData, TPageParam>>;
+  resumePausedMutations(): Promise<unknown>;
+  getQueryCache(): QueryCache;
+  getMutationCache(): MutationCache;
+  getDefaultOptions(): DefaultOptions;
+  setDefaultOptions(options: DefaultOptions): void;
+  setQueryDefaults<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData>(queryKey: QueryKey, options: Partial<OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData>, 'queryKey'>>): void;
+  getQueryDefaults(queryKey: QueryKey): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'>;
+  setMutationDefaults<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(mutationKey: MutationKey, options: OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): void;
+  getMutationDefaults(mutationKey: MutationKey): OmitKeyof<MutationObserverOptions<any, any, any, any>, 'mutationKey'>;
+  defaultQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+  defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
+  clear(): void;
+}
+declare interface QueryClientConfig {
+  queryCache?: QueryCache;
+  mutationCache?: MutationCache;
+  defaultOptions?: DefaultOptions;
+}
+declare interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+  client: QueryClient;
+  queryKey: TQueryKey;
+  queryHash: string;
+  options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+  defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+  state?: QueryState<TData, TError>;
+}
+declare interface QueryFilters<TQueryKey extends QueryKey = QueryKey> {
+  /**
+   * Filter to active queries, inactive queries or all queries
+   */
+  type?: QueryTypeFilter;
+  /**
+   * Match query key exactly
+   */
+  exact?: boolean;
+  /**
+   * Include queries matching this predicate function
+   */
+  predicate?: (query: Query) => boolean;
+  /**
+   * Include queries matching this query key
+   */
+  queryKey?: TQueryKey | TuplePrefixes<TQueryKey>;
+  /**
+   * Include or exclude stale queries
+   */
+  stale?: boolean;
+  /**
+   * Include queries matching their fetchStatus
+   */
+  fetchStatus?: FetchStatus;
+}
+declare type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>;
+declare type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
+  client: QueryClient;
+  queryKey: TQueryKey;
+  signal: AbortSignal;
+  meta: QueryMeta | undefined;
+  pageParam?: unknown;
+  /**
+   * @deprecated
+   * if you want access to the direction, you can add it to the pageParam
+   */
+  direction?: unknown;
+} : {
+  client: QueryClient;
+  queryKey: TQueryKey;
+  signal: AbortSignal;
+  pageParam: TPageParam;
+  /**
+   * @deprecated
+   * if you want access to the direction, you can add it to the pageParam
+   */
+  direction: FetchDirection;
+  meta: QueryMeta | undefined;
+};
+declare type QueryKey = Register extends {
+  queryKey: infer TQueryKey;
+} ? TQueryKey extends ReadonlyArray<unknown> ? TQueryKey : TQueryKey extends Array<unknown> ? TQueryKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+declare type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
+declare type QueryMeta = Register extends {
+  queryMeta: infer TQueryMeta;
+} ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
+declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Subscribable<QueryObserverListener<TData, TError>> {
+  #private;
+  options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+  constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+  protected bindMethods(): void;
+  protected onSubscribe(): void;
+  protected onUnsubscribe(): void;
+  shouldFetchOnReconnect(): boolean;
+  shouldFetchOnWindowFocus(): boolean;
+  destroy(): void;
+  setOptions(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): void;
+  getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+  getCurrentResult(): QueryObserverResult<TData, TError>;
+  trackResult(result: QueryObserverResult<TData, TError>, onPropTracked?: (key: keyof QueryObserverResult) => void): QueryObserverResult<TData, TError>;
+  trackProp(key: keyof QueryObserverResult): void;
+  getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+  refetch({
+    ...options
+  }?: RefetchOptions): Promise<QueryObserverResult<TData, TError>>;
+  fetchOptimistic(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
+  protected fetch(fetchOptions: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
+  protected createResult(query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+  updateResult(): void;
+  onQueryUpdate(): void;
+}
+declare interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
+  /**
+   * The last successfully resolved data for the query.
+   */
+  data: TData | undefined;
+  /**
+   * The timestamp for when the query most recently returned the `status` as `"success"`.
+   */
+  dataUpdatedAt: number;
+  /**
+   * The error object for the query, if an error was thrown.
+   * - Defaults to `null`.
+   */
+  error: TError | null;
+  /**
+   * The timestamp for when the query most recently returned the `status` as `"error"`.
+   */
+  errorUpdatedAt: number;
+  /**
+   * The failure count for the query.
+   * - Incremented every time the query fails.
+   * - Reset to `0` when the query succeeds.
+   */
+  failureCount: number;
+  /**
+   * The failure reason for the query retry.
+   * - Reset to `null` when the query succeeds.
+   */
+  failureReason: TError | null;
+  /**
+   * The sum of all errors.
+   */
+  errorUpdateCount: number;
+  /**
+   * A derived boolean from the `status` variable, provided for convenience.
+   * - `true` if the query attempt resulted in an error.
+   */
+  isError: boolean;
+  /**
+   * Will be `true` if the query has been fetched.
+   */
+  isFetched: boolean;
+  /**
+   * Will be `true` if the query has been fetched after the component mounted.
+   * - This property can be used to not show any previously cached data.
+   */
+  isFetchedAfterMount: boolean;
+  /**
+   * A derived boolean from the `fetchStatus` variable, provided for convenience.
+   * - `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
+   */
+  isFetching: boolean;
+  /**
+   * Is `true` whenever the first fetch for a query is in-flight.
+   * - Is the same as `isFetching && isPending`.
+   */
+  isLoading: boolean;
+  /**
+   * Will be `pending` if there's no cached data and no query attempt was finished yet.
+   */
+  isPending: boolean;
+  /**
+   * Will be `true` if the query failed while fetching for the first time.
+   */
+  isLoadingError: boolean;
+  /**
+   * @deprecated `isInitialLoading` is being deprecated in favor of `isLoading`
+   * and will be removed in the next major version.
+   */
+  isInitialLoading: boolean;
+  /**
+   * A derived boolean from the `fetchStatus` variable, provided for convenience.
+   * - The query wanted to fetch, but has been `paused`.
+   */
+  isPaused: boolean;
+  /**
+   * Will be `true` if the data shown is the placeholder data.
+   */
+  isPlaceholderData: boolean;
+  /**
+   * Will be `true` if the query failed while refetching.
+   */
+  isRefetchError: boolean;
+  /**
+   * Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
+   * - Is the same as `isFetching && !isPending`.
+   */
+  isRefetching: boolean;
+  /**
+   * Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
+   */
+  isStale: boolean;
+  /**
+   * A derived boolean from the `status` variable, provided for convenience.
+   * - `true` if the query has received a response with no errors and is ready to display its data.
+   */
+  isSuccess: boolean;
+  /**
+   * `true` if this observer is enabled, `false` otherwise.
+   */
+  isEnabled: boolean;
+  /**
+   * A function to manually refetch the query.
+   */
+  refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
+  /**
+   * The status of the query.
+   * - Will be:
+   *   - `pending` if there's no cached data and no query attempt was finished yet.
+   *   - `error` if the query attempt resulted in an error.
+   *   - `success` if the query has received a response with no errors and is ready to display its data.
+   */
+  status: QueryStatus;
+  /**
+   * The fetch status of the query.
+   * - `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
+   * - `paused`: The query wanted to fetch, but has been `paused`.
+   * - `idle`: The query is not fetching.
+   * - See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
+   */
+  fetchStatus: FetchStatus;
+  /**
+   * A stable promise that will be resolved with the data of the query.
+   * Requires the `experimental_prefetchInRender` feature flag to be enabled.
+   * @example
+   *
+   * ### Enabling the feature flag
+   * ```ts
+   * const client = new QueryClient({
+   *   defaultOptions: {
+   *     queries: {
+   *       experimental_prefetchInRender: true,
+   *     },
+   *   },
+   * })
+   * ```
+   *
+   * ### Usage
+   * ```tsx
+   * import { useQuery } from '@tanstack/react-query'
+   * import React from 'react'
+   * import { fetchTodos, type Todo } from './api'
+   *
+   * function TodoList({ query }: { query: UseQueryResult<Todo[], Error> }) {
+   *   const data = React.use(query.promise)
+   *
+   *   return (
+   *     <ul>
+   *       {data.map(todo => (
+   *         <li key={todo.id}>{todo.title}</li>
+   *       ))}
+   *     </ul>
+   *   )
+   * }
+   *
+   * export function App() {
+   *   const query = useQuery({ queryKey: ['todos'], queryFn: fetchTodos })
+   *
+   *   return (
+   *     <>
+   *       <h1>Todos</h1>
+   *       <React.Suspense fallback={<div>Loading...</div>}>
+   *         <TodoList query={query} />
+   *       </React.Suspense>
+   *     </>
+   *   )
+   * }
+   * ```
+   */
+  promise: Promise<TData>;
+}
+declare type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
+declare interface QueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+declare interface QueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
+  /**
+   * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.
+   * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
+   * Accepts a boolean or function that returns a boolean.
+   * Defaults to `true`.
+   */
+  enabled?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * The time in milliseconds after data is considered stale.
+   * If set to `Infinity`, the data will never be considered stale.
+   * If set to a function, the function will be executed with the query to compute a `staleTime`.
+   * Defaults to `0`.
+   */
+  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * If set to a number, the query will continuously refetch at this frequency in milliseconds.
+   * If set to a function, the function will be executed with the latest data and query to compute a frequency
+   * Defaults to `false`.
+   */
+  refetchInterval?: number | false | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => number | false | undefined);
+  /**
+   * If set to `true`, the query will continue to refetch while their tab/window is in the background.
+   * Defaults to `false`.
+   */
+  refetchIntervalInBackground?: boolean;
+  /**
+   * If set to `true`, the query will refetch on window focus if the data is stale.
+   * If set to `false`, the query will not refetch on window focus.
+   * If set to `'always'`, the query will always refetch on window focus.
+   * If set to a function, the function will be executed with the latest data and query to compute the value.
+   * Defaults to `true`.
+   */
+  refetchOnWindowFocus?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  /**
+   * If set to `true`, the query will refetch on reconnect if the data is stale.
+   * If set to `false`, the query will not refetch on reconnect.
+   * If set to `'always'`, the query will always refetch on reconnect.
+   * If set to a function, the function will be executed with the latest data and query to compute the value.
+   * Defaults to the value of `networkOnline` (`true`)
+   */
+  refetchOnReconnect?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  /**
+   * If set to `true`, the query will refetch on mount if the data is stale.
+   * If set to `false`, will disable additional instances of a query to trigger background refetch.
+   * If set to `'always'`, the query will always refetch on mount.
+   * If set to a function, the function will be executed with the latest data and query to compute the value
+   * Defaults to `true`.
+   */
+  refetchOnMount?: boolean | 'always' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+  /**
+   * If set to `false`, the query will not be retried on mount if it contains an error.
+   * If set to a function, the function will be executed with the query to compute the value.
+   * Defaults to `true`.
+   */
+  retryOnMount?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * If set, the component will only re-render if any of the listed properties change.
+   * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
+   * When set to `'all'`, the component will re-render whenever a query is updated.
+   * When set to a function, the function will be executed to compute the list of properties.
+   * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.
+   */
+  notifyOnChangeProps?: NotifyOnChangeProps;
+  /**
+   * Whether errors should be thrown instead of setting the `error` property.
+   * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
+   * If set to `false` and `suspense` is `false`, errors are returned as state.
+   * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
+   * Defaults to `false`.
+   */
+  throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
+  /**
+   * This option can be used to transform or select a part of the data returned by the query function.
+   */
+  select?: (data: TQueryData) => TData;
+  /**
+   * If set to `true`, the query will suspend when `status === 'pending'`
+   * and throw errors when `status === 'error'`.
+   * Defaults to `false`.
+   */
+  suspense?: boolean;
+  /**
+   * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.
+   */
+  placeholderData?: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
+  _optimisticResults?: 'optimistic' | 'isRestoring';
+  /**
+   * Enable prefetching during rendering
+   */
+  experimental_prefetchInRender?: boolean;
+}
+declare interface QueryObserverPendingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+declare interface QueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: 'success';
+}
+declare interface QueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+declare type QueryObserverResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError> | QueryObserverPendingResult<TData, TError> | QueryObserverPlaceholderResult<TData, TError>;
+declare interface QueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: 'success';
+}
+declare interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
+  /**
+   * If `false`, failed queries will not retry by default.
+   * If `true`, failed queries will retry infinitely., failureCount: num
+   * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
+   * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
+   */
+  retry?: RetryValue<TError>;
+  retryDelay?: RetryDelayValue<TError>;
+  networkMode?: NetworkMode;
+  /**
+   * The time in milliseconds that unused/inactive cache data remains in memory.
+   * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
+   * When different garbage collection times are specified, the longest one will be used.
+   * Setting it to `Infinity` will disable garbage collection.
+   */
+  gcTime?: number;
+  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken;
+  persister?: QueryPersister<TQueryFnData, TQueryKey, TPageParam>;
+  queryHash?: string;
+  queryKey?: TQueryKey;
+  queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;
+  initialData?: TData | InitialDataFunction<TData>;
+  initialDataUpdatedAt?: number | (() => number | undefined);
+  behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>;
+  /**
+   * Set this to `false` to disable structural sharing between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
+   * Defaults to `true`.
+   */
+  structuralSharing?: boolean | ((oldData: unknown | undefined, newData: unknown) => unknown);
+  _defaulted?: boolean;
+  _type?: 'infinite';
+  /**
+   * Additional payload to be stored on each query.
+   * Use this property to pass information that can be used in other places.
+   */
+  meta?: QueryMeta;
+  /**
+   * Maximum number of pages to store in the data of an infinite query.
+   */
+  maxPages?: number;
+}
+declare type QueryPersister<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? (queryFn: QueryFunction<T, TQueryKey, never>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T> : (queryFn: QueryFunction<T, TQueryKey, TPageParam>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T>;
+declare interface QueryState<TData = unknown, TError = DefaultError> {
+  data: TData | undefined;
+  dataUpdateCount: number;
+  dataUpdatedAt: number;
+  error: TError | null;
+  errorUpdateCount: number;
+  errorUpdatedAt: number;
+  fetchFailureCount: number;
+  fetchFailureReason: TError | null;
+  fetchMeta: FetchMeta | null;
+  isInvalidated: boolean;
+  status: QueryStatus;
+  fetchStatus: FetchStatus;
+}
+declare type QueryStatus = 'pending' | 'error' | 'success';
+declare type QueryTypeFilter = 'all' | 'active' | 'inactive';
+declare interface RefetchOptions extends ResultOptions {
+  /**
+   * If set to `true`, a currently running request will be cancelled before a new request is made
+   *
+   * If set to `false`, no refetch will be made if there is already a request running.
+   *
+   * Defaults to `true`.
+   */
+  cancelRefetch?: boolean;
+}
+declare interface RefetchQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {}
+declare interface Register {}
+declare abstract class Removable {
+  #private;
+  gcTime: number;
+  destroy(): void;
+  protected scheduleGc(): void;
+  protected updateGcTime(newGcTime: number | undefined): void;
+  protected clearGcTimeout(): void;
+  protected abstract optionalRemove(): void;
+}
+declare interface ResetOptions extends RefetchOptions {}
+declare interface ResultOptions {
+  throwOnError?: boolean;
+}
+declare type RetryDelayFunction<TError = DefaultError> = (failureCount: number, error: TError) => number;
+declare type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
+declare type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
+declare interface SetDataOptions {
+  updatedAt?: number;
+}
+declare interface SetStateAction<TData, TError> {
+  type: 'setState';
+  state: Partial<QueryState<TData, TError>>;
+}
+declare type ShouldRetryFunction<TError = DefaultError> = (failureCount: number, error: TError) => boolean;
+declare type SkipToken = typeof skipToken;
+declare const skipToken: unique symbol;
+declare type StaleTime = number | 'static';
+declare type StaleTimeFunction<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = StaleTime | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => StaleTime);
+declare class Subscribable<TListener extends Function> {
+  protected listeners: Set<TListener>;
+  constructor();
+  subscribe(listener: TListener): () => void;
+  hasListeners(): boolean;
+  protected onSubscribe(): void;
+  protected onUnsubscribe(): void;
+}
+declare interface SuccessAction<TData> {
+  data: TData | undefined;
+  type: 'success';
+  dataUpdatedAt?: number;
+  manual?: boolean;
+}
+declare interface SuccessAction_2<TData> {
+  type: 'success';
+  data: TData;
+}
+/**
+ * In many cases code wants to delay to the next event loop tick; this is not
+ * mediated by {@link timeoutManager}.
+ *
+ * This function is provided to make auditing the `tanstack/query-core` for
+ * incorrect use of system `setTimeout` easier.
+ */
+declare type ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
+declare type TransformerFn = (data: any) => any;
+/**
+ * This function takes a Promise-like input and detects whether the data
+ * is synchronously available or not.
+ *
+ * It does not inspect .status, .value or .reason properties of the promise,
+ * as those are not always available, and the .status of React's promises
+ * should not be considered part of the public API.
+ */
+declare type TuplePrefixes<T extends ReadonlyArray<unknown>> = T extends readonly [] ? readonly [] : TuplePrefixes<DropLast<T>> | T;
+declare type UnsetMarker = typeof unsetMarker;
+declare const unsetMarker: unique symbol;
+declare type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
+declare type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & { [_ in TKey]: {} };
+//#endregion
+//#region src/queries/contentQueries.d.ts
+/**
+ * Query options factory for content queries
+ * Use with TanStack Query's useQuery hook
+ */
+declare const contentQueries: {
+  /**
+   * Query options for paginated content list
+   * @param params - List parameters including type, pagination, filters
+   */
+  list: <C extends CustomFields = CustomFields>(params?: ContentListParams) => OmitKeyof<_$_tanstack_react_query0.UseQueryOptions<ContentResponse<C>, Error, ContentResponse<C>, readonly ["content", "list", string, ContentListParams]>, "queryFn"> & {
+    queryFn?: QueryFunction<ContentResponse<C>, readonly ["content", "list", string, ContentListParams], never> | undefined;
+  } & {
+    queryKey: readonly ["content", "list", string, ContentListParams] & {
+      [dataTagSymbol]: ContentResponse<C>;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  /**
+   * Query options for a single content item by ID
+   * @param id - Content item ID
+   */
+  detail: <C extends CustomFields = CustomFields>(id: number) => OmitKeyof<_$_tanstack_react_query0.UseQueryOptions<ApiResponse<ContentDto<C>>, Error, ApiResponse<ContentDto<C>>, readonly ["content", "detail", number]>, "queryFn"> & {
+    queryFn?: QueryFunction<ApiResponse<ContentDto<C>>, readonly ["content", "detail", number], never> | undefined;
+  } & {
+    queryKey: readonly ["content", "detail", number] & {
+      [dataTagSymbol]: ApiResponse<ContentDto<C>>;
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+  /**
+   * Query options for fetching all content items (across all pages)
+   * @param params - List parameters (without page)
+   * @param options - Fetch options including mapping and deduplication
+   */
+  listAll: <C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, "page"> & {
+    page?: never;
+  }, options?: FetchAllOptions<C, T>) => OmitKeyof<_$_tanstack_react_query0.UseQueryOptions<T[], Error, T[], readonly ["content", "all", string, {
+    readonly mode: "all";
+    readonly size?: number;
+    readonly sortBy?: string;
+    readonly direction?: "ASC" | "DESC";
+    readonly type?: string;
+    readonly filters?: Record<string, string | number | boolean | null | undefined>;
+  }]>, "queryFn"> & {
+    queryFn?: QueryFunction<T[], readonly ["content", "all", string, {
+      readonly mode: "all";
+      readonly size?: number;
+      readonly sortBy?: string;
+      readonly direction?: "ASC" | "DESC";
+      readonly type?: string;
+      readonly filters?: Record<string, string | number | boolean | null | undefined>;
+    }], never> | undefined;
+  } & {
+    queryKey: readonly ["content", "all", string, {
+      readonly mode: "all";
+      readonly size?: number;
+      readonly sortBy?: string;
+      readonly direction?: "ASC" | "DESC";
+      readonly type?: string;
+      readonly filters?: Record<string, string | number | boolean | null | undefined>;
+    }] & {
+      [dataTagSymbol]: T[];
+      [dataTagErrorSymbol]: Error;
+    };
+  };
+};
+//#endregion
+//#region src/queries/queryKeys.d.ts
+/**
+ * Hierarchical query key factory for content queries
+ * Following TanStack Query best practices for key structure
+ */
+declare const contentKeys: {
+  /**
+   * Base key for all content queries
+   */
+  all: readonly ["content"];
+  /**
+   * Key for all list queries
+   */
+  lists: () => readonly ["content", "list"];
+  /**
+   * Key for a specific list query with parameters
+   * @param type - Content type (e.g., 'NEWS', 'REPORT')
+   * @param params - Additional list parameters
+   */
+  list: (type: string | undefined, params: ContentListParams) => readonly ["content", "list", string, ContentListParams];
+  /**
+   * Key for all detail queries
+   */
+  details: () => readonly ["content", "detail"];
+  /**
+   * Key for a specific detail query by ID
+   * @param id - Content item ID
+   */
+  detail: (id: number) => readonly ["content", "detail", number];
+  /**
+   * Key for all "fetch all" queries
+   */
+  allLists: () => readonly ["content", "all"];
+  /**
+   * Key for a specific "fetch all" query
+   * @param type - Content type
+   * @param params - List parameters (without page)
+   */
+  allList: (type: string | undefined, params: Omit<ContentListParams, "page">) => readonly ["content", "all", string, {
+    readonly mode: "all";
+    readonly size?: number;
+    readonly sortBy?: string;
+    readonly direction?: "ASC" | "DESC";
+    readonly type?: string;
+    readonly filters?: Record<string, string | number | boolean | null | undefined>;
+  }];
+};
+//#endregion
+//#region src/queries/useContentQueries.d.ts
+/**
+ * Hook for fetching paginated content list
+ * @param params - List parameters including type, pagination, filters
+ */
+declare function useContentList<C extends CustomFields = CustomFields>(params?: ContentListParams): UseQueryResult<ContentResponse<C>>;
+/**
+ * Hook for fetching a single content item by ID
+ * @param id - Content item ID
+ */
+declare function useContentDetail<C extends CustomFields = CustomFields>(id: number): UseQueryResult<ApiResponse<ContentDto<C>>>;
+/**
+ * Hook for fetching all content items across pages
+ * @param params - List parameters (without page)
+ * @param options - Fetch options including mapping and deduplication
+ */
+declare function useContentAll<C extends CustomFields = CustomFields, T = ContentDto<C>>(params: Omit<ContentListParams, 'page'> & {
+  page?: never;
+}, options?: FetchAllOptions<C, T>): UseQueryResult<T[]>;
+/**
+ * Hook for prefetching content queries
+ * Useful for optimistic navigation and hover effects
+ */
+declare function useContentPrefetch(): {
+  /**
+   * Prefetch a content list
+   */
+  prefetchList: <C extends CustomFields = CustomFields>(params: ContentListParams) => Promise<void>;
+  /**
+   * Prefetch a content detail
+   */
+  prefetchDetail: <C extends CustomFields = CustomFields>(id: number) => Promise<void>;
+  /**
+   * Invalidate content lists (force refetch)
+   */
+  invalidateLists: () => Promise<void>;
+  /**
+   * Invalidate a specific content detail
+   */
+  invalidateDetail: (id: number) => Promise<void>;
+  /**
+   * Invalidate all content queries
+   */
+  invalidateAll: () => Promise<void>;
+};
+//#endregion
+//#region src/utils/assetUrl.d.ts
+type BuildAssetUrlOpts = {
+  apiBase?: string;
+  fileBase?: string;
+};
+declare const buildAssetUrl: (rawPath?: string | null, opts?: BuildAssetUrlOpts) => string;
+//#endregion
+//#region src/utils/normalization.d.ts
+/**
+ * Normalize a content item to a standard format with asset URLs resolved
+ *
+ * This function provides a default normalization strategy that:
+ * - Extracts common fields from customFields
+ * - Resolves asset URLs using SDK configuration
+ * - Handles PDF path resolution for different content types
+ * - Provides sensible defaults for missing fields
+ *
+ * @param item - Raw content item from the API
+ * @returns Normalized content item
+ */
+declare function normalizeContentItem<C extends CustomFields = CustomFields>(item: ContentDto<C>): NormalizedContentItem;
+/**
+ * Build an asset URL using the SDK's configured base URLs
+ * This is a convenience wrapper that automatically uses SDK config
+ *
+ * @param path - Path to the asset (can be relative or absolute)
+ * @returns Full URL to the asset
+ */
+declare function buildAssetUrlWithConfig(path?: string | null): string;
+//#endregion
+//#region src/utils/richText.d.ts
+/**
+ * Strips HTML tags from a string, returning plain text.
+ *
+ * Uses a regex approach rather than the browser DOM (`document.createElement`)
+ * so it is safe to call in any environment: browser, Node.js, SSR, edge functions.
+ *
+ * Designed for TipTap-generated HTML (paragraphs, bold, italic, lists, links).
+ * Block-level elements (`<p>`, `<li>`, `<br>`) are replaced with a space so
+ * adjacent words from different blocks are not concatenated. The result is
+ * then trimmed and excess internal whitespace is normalized.
+ *
+ * @example
+ * stripHtmlTags('<p>Hello <strong>world</strong></p>') // → 'Hello world'
+ * stripHtmlTags('<ul><li>A</li><li>B</li></ul>')       // → 'A B'
+ */
+declare function stripHtmlTags(html: string): string;
+/**
+ * Returns `true` if the given string contains HTML markup.
+ *
+ * Specifically detects well-formed opening HTML tags — a `<` followed by a
+ * known tag name and at least one non-`>` character or an immediate `>`.
+ * This avoids false-positives from plain-text angle brackets such as
+ * comparison operators ("if x < 10 then").
+ *
+ * Useful for deciding whether to render a value via a rich text renderer
+ * (TipTap, `dangerouslySetInnerHTML`) or as plain text.
+ *
+ * @example
+ * isHtmlContent('<p>Bold</p>')            // → true
+ * isHtmlContent('Just text')              // → false
+ * isHtmlContent('if x < 10 then')        // → false
+ */
+declare function isHtmlContent(value: string): boolean;
+//#endregion
+//#region src/errors/CmsError.d.ts
+declare class CmsError extends Error {
+  readonly status?: number;
+  readonly data?: unknown;
+  constructor(message: string, opts?: {
+    status?: number;
+    data?: unknown;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/config/sdkConfig.d.ts
+/**
+ * Get the current SDK configuration
+ */
+declare function getConfig(): SdkConfig;
+/**
+ * Set the SDK configuration
+ */
+declare function setConfig(config: SdkConfig): void;
+/**
+ * Check if SDK is initialized
+ */
+declare function isInitialized(): boolean;
+/**
+ * Reset configuration (useful for testing)
+ */
+declare function resetConfig(): void;
+//#endregion
+export { ApiResponse, CmsError, ContentDto, ContentListParams, ContentResponse, CustomFields, FetchAllOptions, JsonPrimitive, JsonValue, NormalizedContentItem, PaginatedData, SdkConfig, apiClient, buildAssetUrl, buildAssetUrlWithConfig, contentKeys, contentQueries, createApiClient, downloadFile, fetchAllContent, fetchContentById, fetchContentByType, getApiClient, getConfig, isHtmlContent, isInitialized, normalizeContentItem, resetApiClient, resetConfig, setConfig, stripHtmlTags, useContentAll, useContentDetail, useContentList, useContentPrefetch };
+//# sourceMappingURL=index.d.cts.map