@ludo.ninja/components 2.3.6 → 2.3.8

package/build/api/server-preferences/mutations/useSaveUserInterests/index.d.ts

@@ -0,0 +1,4 @@
+declare const useSaveUserInterests: () => {
+    saveUserInterests: (interests: string[]) => Promise<void>;
+};
+export default useSaveUserInterests;

package/build/api/server-preferences/mutations/useSaveUserInterests/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useSaveUserInterests = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.preferencesSchema.useSaveUserInterestsMutation({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ saveUserInterests }) => {
+            if (saveUserInterests) {
+                openAlert({
+                    ...data_1.alertSuccess,
+                    caption: 'Interests successfully added!',
+                    text: '',
+                });
+            }
+            else {
+                openAlert({
+                    ...data_1.alertError,
+                    caption: 'Sorry something went wrong :(',
+                    text: '',
+                });
+            }
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    async function saveUserInterests(interests) {
+        await mutate({
+            variables: { interests },
+        });
+    }
+    return { saveUserInterests };
+};
+exports.default = useSaveUserInterests;

package/build/api/server-preferences/queries/fetchSearchResultSelections/index.d.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<schema.IFetchSearchResultSelectionsQuery> | {
+    data: {
+        fetchSearchResultSelections: null;
+    };
+}>;
+export declare const useFetchSearchResultSelections: () => {
+    resultTimeSelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultSelections: {
+        typeSelections: Array<schema.Maybe<(Pick<schema.ISelection, "label"> & {
+            id: schema.ISelection["name"];
+        })>>;
+        blockchainSelections: Array<schema.Maybe<(Pick<schema.ISelection, "label"> & {
+            id: schema.ISelection["name"];
+        })>>;
+        categorySelections: Array<schema.Maybe<(Pick<schema.ISelection, "label"> & {
+            id: schema.ISelection["name"];
+        })>>;
+        timeSelections: Array<schema.Maybe<(Pick<schema.ISelection, "label"> & {
+            id: schema.ISelection["name"];
+        })>>;
+        statusSelections: Array<schema.Maybe<(Pick<schema.ISelection, "label"> & {
+            id: schema.ISelection["name"];
+        })>>;
+    } | undefined;
+};

package/build/api/server-preferences/queries/fetchSearchResultSelections/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchSearchResultSelections = exports.prefetchSearchResultSelections = void 0;
+const api_1 = require("@ludo.ninja/api");
+const context = {
+    uri: api_1.hosts.preferencesHost,
+};
+const prefetchSearchResultSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultSelectionsDocument,
+        context,
+        fetchPolicy: 'no-cache',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultSelections = prefetchSearchResultSelections;
+const useFetchSearchResultSelections = () => {
+    const { error, loading, data } = api_1.preferencesSchema.useFetchSearchResultSelectionsQuery({
+        context,
+        fetchPolicy: 'no-cache',
+    });
+    return {
+        resultTimeSelectionsLoading: loading,
+        error,
+        searchResultSelections: data?.fetchSearchResultSelections,
+    };
+};
+exports.useFetchSearchResultSelections = useFetchSearchResultSelections;

package/build/api/server-preferences/queries/fetchSearchResultSelections/queryData.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import * as querystring from 'querystring';
+import { ICollectionFilterInput, ICreationFilterInput } from '@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema';
+export interface DefaultsCollectionsSearchPageProps extends ICollectionFilterInput {
+    term: string;
+}
+export interface DefaultsNftSearchPageProps extends ICreationFilterInput {
+    term: string;
+}
+export declare const getQueryData: (query: querystring.ParsedUrlQuery, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<{
+    nft(): DefaultsNftSearchPageProps;
+    collections(): DefaultsCollectionsSearchPageProps;
+} | null>;

package/build/api/server-preferences/queries/fetchSearchResultSelections/queryData.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryData = void 0;
+const index_1 = require("./index");
+const helpers_1 = require("../../../../system/Filters/helpers");
+const getQueryData = async (query, apolloClient) => {
+    const { term, type, time, blockchain, category, status } = query;
+    const { data: { fetchSearchResultSelections }, } = await (0, index_1.prefetchSearchResultSelections)(apolloClient);
+    // const res = await prefetchSearchResultSelections(apolloClient);
+    // console.log(JSON.stringify(res, null, ' '));
+    if (!fetchSearchResultSelections) {
+        // redirect to home page if error fetch selections
+        return null;
+    }
+    const defaults = {
+        term: term ? term : '',
+        time: (0, helpers_1.findDefaultFilterValue)(time, fetchSearchResultSelections.timeSelections, fetchSearchResultSelections.timeSelections[0]?.id),
+        blockchain: (0, helpers_1.findDefaultFilterValue)(blockchain, fetchSearchResultSelections.blockchainSelections, fetchSearchResultSelections.blockchainSelections[0]?.id),
+        category: (0, helpers_1.findDefaultFilterValue)(category, fetchSearchResultSelections.categorySelections, fetchSearchResultSelections.categorySelections[0]?.id),
+        status: (0, helpers_1.findDefaultFilterValue)(status, fetchSearchResultSelections.statusSelections, fetchSearchResultSelections.statusSelections[0]?.id),
+    };
+    return {
+        nft() {
+            return {
+                ...defaults,
+                type: (0, helpers_1.findDefaultFilterValue)(type, fetchSearchResultSelections.typeSelections, fetchSearchResultSelections.typeSelections[0]?.id),
+            };
+        },
+        collections() {
+            return defaults;
+        },
+        // gallery() {
+        //   return;
+        // },
+    };
+};
+exports.getQueryData = getQueryData;

package/build/api/server-preferences/queries/useFetchExpectations/index.d.ts

@@ -0,0 +1,7 @@
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+declare const useFetchExpectations: () => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    expectations: schema.IExpectation[] | null;
+};
+export default useFetchExpectations;

package/build/api/server-preferences/queries/useFetchExpectations/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const useFetchExpectations = () => {
+    const [expectations, setExpectations] = (0, react_1.useState)(null);
+    const { loading, error } = api_1.preferencesSchema.useFetchExpectationsQuery({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchExpectations }) => {
+            setExpectations(fetchExpectations);
+        },
+        onError: () => {
+            setExpectations([]);
+        },
+    });
+    return { loading, error, expectations };
+};
+exports.default = useFetchExpectations;

package/build/api/server-preferences/queries/useFetchInterests/index.d.ts

@@ -0,0 +1,7 @@
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+declare const useFetchInterests: () => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    interests: schema.IInterest[] | null;
+};
+export default useFetchInterests;

package/build/api/server-preferences/queries/useFetchInterests/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const useFetchInterests = () => {
+    const [interests, setInterests] = (0, react_1.useState)(null);
+    const { loading, error } = api_1.preferencesSchema.useFetchInterestsQuery({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchInterests }) => {
+            setInterests(fetchInterests);
+        },
+        onError: () => {
+            setInterests(null);
+        },
+    });
+    return { loading, error, interests };
+};
+exports.default = useFetchInterests;

package/build/api/server-preferences/queries/useFetchSearchResultTimeSelection/index.d.ts

@@ -0,0 +1,12 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { ISelectInput } from '../../../../system/Forms/Selects/MobileSelect';
+export declare const prefetchSearchResultTimeSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultTimeSelections: null;
+    };
+}>;
+export declare const useFetchSearchResultTimeSelections: () => {
+    resultTimeSelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultTimeSelections: ISelectInput[] | null;
+};

package/build/api/server-preferences/queries/useFetchSearchResultTimeSelection/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchSearchResultTimeSelections = exports.prefetchSearchResultTimeSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultTimeSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultTimeSelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultTimeSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultTimeSelections = prefetchSearchResultTimeSelections;
+const useFetchSearchResultTimeSelections = () => {
+    const [searchResultTimeSelections, setSearchResultTimeSelections] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultTimeSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultTimeSelections }) => {
+            setSearchResultTimeSelections(fetchSearchResultTimeSelections);
+        },
+        onError: () => {
+            setSearchResultTimeSelections(null);
+        },
+    });
+    return {
+        resultTimeSelectionsLoading: loading,
+        error,
+        searchResultTimeSelections,
+    };
+};
+exports.useFetchSearchResultTimeSelections = useFetchSearchResultTimeSelections;

package/build/api/server-preferences/queries/useFetchUserInterests/index.d.ts

@@ -0,0 +1,7 @@
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+declare const useFetchUserInterests: () => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    userInterests: schema.IUserInterest[] | null;
+};
+export default useFetchUserInterests;

package/build/api/server-preferences/queries/useFetchUserInterests/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useFetchUserInterests = () => {
+    const [userInterests, setInterests] = (0, react_1.useState)(null);
+    const { loading, error } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchUserInterestsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchUserInterests }) => {
+            setInterests(fetchUserInterests);
+        },
+        onError: () => {
+            setInterests(null);
+        },
+    });
+    return { loading, error, userInterests };
+};
+exports.default = useFetchUserInterests;

package/build/api/server-preferences/queries/useSearchResultBlockchainSelections/index.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { ISelectInput } from '../../../../system/Forms/Selects/MobileSelect';
+export declare const prefetchSearchResultBlockchainSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultBlockchainSelections: null;
+    };
+}>;
+export declare const useSearchResultBlockchainSelections: () => {
+    searchResultBlockchainSelectionsLoading: boolean;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultBlockchainSelections: ISelectInput[] | null;
+};

package/build/api/server-preferences/queries/useSearchResultBlockchainSelections/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSearchResultBlockchainSelections = exports.prefetchSearchResultBlockchainSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultBlockchainSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultBlockchainSelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultBlockchainSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultBlockchainSelections = prefetchSearchResultBlockchainSelections;
+const useSearchResultBlockchainSelections = () => {
+    const [searchResultBlockchainSelections, setSearchResultBlockchainSelections,] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultBlockchainSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultBlockchainSelections }) => {
+            setSearchResultBlockchainSelections(fetchSearchResultBlockchainSelections);
+        },
+        onError: () => {
+            setSearchResultBlockchainSelections(null);
+        },
+    });
+    return {
+        searchResultBlockchainSelectionsLoading: loading,
+        loading,
+        error,
+        searchResultBlockchainSelections,
+    };
+};
+exports.useSearchResultBlockchainSelections = useSearchResultBlockchainSelections;

package/build/api/server-preferences/queries/useSearchResultCategorySelections/index.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultCategorySelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultCategorySelections: null;
+    };
+}>;
+declare const useSearchResultCategorySelections: () => {
+    categorySelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultCategorySelections: schema.Maybe<Pick<schema.ISelection, "name" | "label">>[] | null;
+};
+export default useSearchResultCategorySelections;

package/build/api/server-preferences/queries/useSearchResultCategorySelections/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchSearchResultCategorySelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultCategorySelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultCategorySelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultCategorySelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultCategorySelections = prefetchSearchResultCategorySelections;
+const useSearchResultCategorySelections = () => {
+    const [searchResultCategorySelections, setSearchResultCategorySelections] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultCategorySelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultCategorySelections }) => {
+            setSearchResultCategorySelections(fetchSearchResultCategorySelections);
+        },
+        onError: () => {
+            setSearchResultCategorySelections(null);
+        },
+    });
+    return {
+        categorySelectionsLoading: loading,
+        error,
+        searchResultCategorySelections,
+    };
+};
+exports.default = useSearchResultCategorySelections;

package/build/api/server-preferences/queries/useSearchResultStatusSelections/index.d.ts

@@ -0,0 +1,14 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultStatusSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultStatusSelections: null;
+    };
+}>;
+declare const useSearchResultStatusSelections: () => {
+    searchResultStatusSelectionsLoading: boolean;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultStatusSelections: schema.Maybe<Pick<schema.ISelection, "name" | "label">>[] | null;
+};
+export default useSearchResultStatusSelections;

package/build/api/server-preferences/queries/useSearchResultStatusSelections/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchSearchResultStatusSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultStatusSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultStatusSelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultStatusSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultStatusSelections = prefetchSearchResultStatusSelections;
+const useSearchResultStatusSelections = () => {
+    const [searchResultStatusSelections, setSearchResultStatusSelections] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultStatusSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultStatusSelections }) => {
+            setSearchResultStatusSelections(fetchSearchResultStatusSelections);
+        },
+        onError: () => {
+            setSearchResultStatusSelections(null);
+        },
+    });
+    return {
+        searchResultStatusSelectionsLoading: loading,
+        loading,
+        error,
+        searchResultStatusSelections,
+    };
+};
+exports.default = useSearchResultStatusSelections;

package/build/api/server-preferences/queries/useSearchResultTypeSelections/index.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultTypeSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSetsSearchResultTypeSelections: null;
+    };
+}>;
+export declare const useSearchResultTypeSelections: () => {
+    resultTypeSelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    data: any;
+    searchResultTypeSelections: schema.Maybe<Pick<schema.ISelection, "name" | "label">>[] | null;
+};

package/build/api/server-preferences/queries/useSearchResultTypeSelections/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSearchResultTypeSelections = exports.prefetchSearchResultTypeSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultTypeSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: (0, client_1.gql) `
+        query FetchSetsSearchResultTypeSelections {
+          fetchSearchResultTypeSelections {
+            name
+            label
+          }
+        }
+      `,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSetsSearchResultTypeSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultTypeSelections = prefetchSearchResultTypeSelections;
+const useSearchResultTypeSelections = () => {
+    const [searchResultTypeSelections, setSearchResultTypeSelections] = (0, react_1.useState)(null);
+    const { data, error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSetsSearchResultTypeSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSetsSearchResultTypeSelections }) => {
+            setSearchResultTypeSelections(fetchSetsSearchResultTypeSelections);
+        },
+        onError: () => {
+            setSearchResultTypeSelections(null);
+        },
+    });
+    return {
+        resultTypeSelectionsLoading: loading,
+        error,
+        data,
+        searchResultTypeSelections,
+    };
+};
+exports.useSearchResultTypeSelections = useSearchResultTypeSelections;

package/build/api/server-search/queries/useFetchAllCreations/index.d.ts

@@ -0,0 +1,32 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { ApolloClient, NormalizedCacheObject } from "@apollo/client";
+import { searchSchema as schema } from "@ludo.ninja/api";
+export declare const prefetchAllCreations: ({ page }: schema.IQueryFetchAllCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchAllCreations: null;
+    };
+}>;
+export declare const useFetchAllCreations: ({ page }: schema.IQueryFetchAllCreationsArgs) => {
+    loadMore: (pageToken: string | null) => Promise<void>;
+    loading: boolean;
+    refetchQuery: () => Promise<void>;
+    error: import("@apollo/client").ApolloError | undefined;
+    allCreations: TCreation[];
+    nextPageToken: string | null;
+};
+declare const _default: {
+    useFetchAllCreations: ({ page }: schema.IQueryFetchAllCreationsArgs) => {
+        loadMore: (pageToken: string | null) => Promise<void>;
+        loading: boolean;
+        refetchQuery: () => Promise<void>;
+        error: import("@apollo/client").ApolloError | undefined;
+        allCreations: TCreation[];
+        nextPageToken: string | null;
+    };
+    prefetchAllCreations: ({ page }: schema.IQueryFetchAllCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            fetchAllCreations: null;
+        };
+    }>;
+};
+export default _default;