import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
const defaultOptions = {};
export var IAccessType;
(function (IAccessType) {
    IAccessType["Public"] = "PUBLIC";
    IAccessType["Restricted"] = "RESTRICTED";
})(IAccessType || (IAccessType = {}));
export var IAuthorityType;
(function (IAuthorityType) {
    IAuthorityType["Medias"] = "MEDIAS";
    IAuthorityType["Search"] = "SEARCH";
})(IAuthorityType || (IAuthorityType = {}));
export var IBlockchains;
(function (IBlockchains) {
    IBlockchains["BaseMainnet"] = "BASE_MAINNET";
    IBlockchains["BaseSepolia"] = "BASE_SEPOLIA";
    IBlockchains["BscMainnet"] = "BSC_MAINNET";
    IBlockchains["BscTestnet"] = "BSC_TESTNET";
    IBlockchains["EthereumMainnet"] = "ETHEREUM_MAINNET";
    IBlockchains["EthereumSepolia"] = "ETHEREUM_SEPOLIA";
    IBlockchains["PolygonAmoy"] = "POLYGON_AMOY";
    IBlockchains["PolygonMainnet"] = "POLYGON_MAINNET";
    IBlockchains["TonMainnet"] = "TON_MAINNET";
    IBlockchains["TonTestnet"] = "TON_TESTNET";
})(IBlockchains || (IBlockchains = {}));
export var IDevicePlatform;
(function (IDevicePlatform) {
    IDevicePlatform["Android"] = "ANDROID";
    IDevicePlatform["Computer"] = "COMPUTER";
    IDevicePlatform["Ios"] = "IOS";
    IDevicePlatform["Unknown"] = "UNKNOWN";
})(IDevicePlatform || (IDevicePlatform = {}));
export var ILeaderboardType;
(function (ILeaderboardType) {
    ILeaderboardType["Airdrops"] = "AIRDROPS";
    ILeaderboardType["Projects"] = "PROJECTS";
})(ILeaderboardType || (ILeaderboardType = {}));
export var ILocationType;
(function (ILocationType) {
    ILocationType["Continent"] = "CONTINENT";
    ILocationType["Country"] = "COUNTRY";
})(ILocationType || (ILocationType = {}));
export var ILoginSource;
(function (ILoginSource) {
    ILoginSource["Backoffice"] = "BACKOFFICE";
    ILoginSource["Extension"] = "EXTENSION";
    ILoginSource["Portal"] = "PORTAL";
    ILoginSource["TgMiniApp"] = "TG_MINI_APP";
    ILoginSource["Unknown"] = "UNKNOWN";
})(ILoginSource || (ILoginSource = {}));
export var INotificationDestination;
(function (INotificationDestination) {
    INotificationDestination["Ludox"] = "LUDOX";
    INotificationDestination["TapToEarnGame"] = "TAP_TO_EARN_GAME";
    INotificationDestination["Telegram"] = "TELEGRAM";
    INotificationDestination["Webapp"] = "WEBAPP";
})(INotificationDestination || (INotificationDestination = {}));
export var IOpportunityType;
(function (IOpportunityType) {
    IOpportunityType["Event"] = "EVENT";
    IOpportunityType["Marketing"] = "MARKETING";
    IOpportunityType["NftMinting"] = "NFT_MINTING";
    IOpportunityType["TokenAirdrop"] = "TOKEN_AIRDROP";
})(IOpportunityType || (IOpportunityType = {}));
export var IPayloadType;
(function (IPayloadType) {
    IPayloadType["UserRank"] = "USER_RANK";
    IPayloadType["UserWallet"] = "USER_WALLET";
})(IPayloadType || (IPayloadType = {}));
export var IProjectType;
(function (IProjectType) {
    IProjectType["AiAgents"] = "AI_AGENTS";
    IProjectType["DeFi"] = "DE_FI";
    IProjectType["GameFi"] = "GAME_FI";
    IProjectType["MemeCoins"] = "MEME_COINS";
})(IProjectType || (IProjectType = {}));
export var IPurchaseType;
(function (IPurchaseType) {
    IPurchaseType["Publisher"] = "PUBLISHER";
    IPurchaseType["Xp"] = "XP";
})(IPurchaseType || (IPurchaseType = {}));
export var IReftypeColor;
(function (IReftypeColor) {
    IReftypeColor["Black"] = "BLACK";
    IReftypeColor["Blue"] = "BLUE";
    IReftypeColor["Gold"] = "GOLD";
    IReftypeColor["Green"] = "GREEN";
    IReftypeColor["Grey"] = "GREY";
    IReftypeColor["Orange"] = "ORANGE";
    IReftypeColor["Purple"] = "PURPLE";
    IReftypeColor["Red"] = "RED";
    IReftypeColor["White"] = "WHITE";
    IReftypeColor["Yellow"] = "YELLOW";
})(IReftypeColor || (IReftypeColor = {}));
export var ISortDirection;
(function (ISortDirection) {
    ISortDirection["Asc"] = "asc";
    ISortDirection["Desc"] = "desc";
})(ISortDirection || (ISortDirection = {}));
export var ITariffPlan;
(function (ITariffPlan) {
    ITariffPlan["Admin"] = "ADMIN";
    ITariffPlan["Backend"] = "BACKEND";
    ITariffPlan["Bot"] = "BOT";
    ITariffPlan["Demo"] = "DEMO";
    ITariffPlan["Extension"] = "EXTENSION";
    ITariffPlan["Kyc"] = "KYC";
})(ITariffPlan || (ITariffPlan = {}));
export var ITrafficReferralType;
(function (ITrafficReferralType) {
    ITrafficReferralType["Brand"] = "BRAND";
    ITrafficReferralType["Opportunity"] = "OPPORTUNITY";
    ITrafficReferralType["Profile"] = "PROFILE";
    ITrafficReferralType["Project"] = "PROJECT";
})(ITrafficReferralType || (ITrafficReferralType = {}));
export const AddInviteCodesDocument = gql `
    mutation AddInviteCodes($userId: String!, $codesNum: Int!, $reftypeId: String) {
  addInviteCodes(userId: $userId, codesNum: $codesNum, reftypeId: $reftypeId)
}
    `;
/**
 * __useAddInviteCodesMutation__
 *
 * To run a mutation, you first call `useAddInviteCodesMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddInviteCodesMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [addInviteCodesMutation, { data, loading, error }] = useAddInviteCodesMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *      codesNum: // value for 'codesNum'
 *      reftypeId: // value for 'reftypeId'
 *   },
 * });
 */
export function useAddInviteCodesMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(AddInviteCodesDocument, options);
}
export const ChangeXpPointsDocument = gql `
    mutation ChangeXpPoints($userId: ID!, $pointsDiff: Int!) {
  changeXpPoints(userId: $userId, pointsDiff: $pointsDiff)
}
    `;
/**
 * __useChangeXpPointsMutation__
 *
 * To run a mutation, you first call `useChangeXpPointsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useChangeXpPointsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [changeXpPointsMutation, { data, loading, error }] = useChangeXpPointsMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *      pointsDiff: // value for 'pointsDiff'
 *   },
 * });
 */
export function useChangeXpPointsMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(ChangeXpPointsDocument, options);
}
export const CreateCategoryDocument = gql `
    mutation CreateCategory($name: String!, $matchingWords: [String!]!) {
  createCategory(name: $name, matchingWords: $matchingWords)
}
    `;
/**
 * __useCreateCategoryMutation__
 *
 * To run a mutation, you first call `useCreateCategoryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateCategoryMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createCategoryMutation, { data, loading, error }] = useCreateCategoryMutation({
 *   variables: {
 *      name: // value for 'name'
 *      matchingWords: // value for 'matchingWords'
 *   },
 * });
 */
export function useCreateCategoryMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateCategoryDocument, options);
}
export const CreateBrandDocument = gql `
    mutation CreateBrand($brand: BrandInput!, $file: Upload) {
  createBrand(brand: $brand, file: $file)
}
    `;
/**
 * __useCreateBrandMutation__
 *
 * To run a mutation, you first call `useCreateBrandMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateBrandMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createBrandMutation, { data, loading, error }] = useCreateBrandMutation({
 *   variables: {
 *      brand: // value for 'brand'
 *      file: // value for 'file'
 *   },
 * });
 */
export function useCreateBrandMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateBrandDocument, options);
}
export const CreateCompanyTokenDocument = gql `
    mutation CreateCompanyToken($input: CompanyTokenInput!) {
  createCompanyToken(input: $input)
}
    `;
/**
 * __useCreateCompanyTokenMutation__
 *
 * To run a mutation, you first call `useCreateCompanyTokenMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateCompanyTokenMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createCompanyTokenMutation, { data, loading, error }] = useCreateCompanyTokenMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateCompanyTokenMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateCompanyTokenDocument, options);
}
export const CreateAdminOpportunityDocument = gql `
    mutation createAdminOpportunity($file: Upload, $input: AdminOpportunityInput!) {
  createAdminOpportunity(file: $file, input: $input)
}
    `;
/**
 * __useCreateAdminOpportunityMutation__
 *
 * To run a mutation, you first call `useCreateAdminOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateAdminOpportunityMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createAdminOpportunityMutation, { data, loading, error }] = useCreateAdminOpportunityMutation({
 *   variables: {
 *      file: // value for 'file'
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateAdminOpportunityMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateAdminOpportunityDocument, options);
}
export const CreateProjectDocument = gql `
    mutation CreateProject($blockchain: String!, $contract: String!) {
  createProject(blockchain: $blockchain, contract: $contract)
}
    `;
/**
 * __useCreateProjectMutation__
 *
 * To run a mutation, you first call `useCreateProjectMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateProjectMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createProjectMutation, { data, loading, error }] = useCreateProjectMutation({
 *   variables: {
 *      blockchain: // value for 'blockchain'
 *      contract: // value for 'contract'
 *   },
 * });
 */
export function useCreateProjectMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateProjectDocument, options);
}
export const CreatePublisherDocument = gql `
    mutation CreatePublisher($input: PublisherInput!) {
  createPublisher(input: $input)
}
    `;
/**
 * __useCreatePublisherMutation__
 *
 * To run a mutation, you first call `useCreatePublisherMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreatePublisherMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createPublisherMutation, { data, loading, error }] = useCreatePublisherMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreatePublisherMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreatePublisherDocument, options);
}
export const CreateReferralTypeDocument = gql `
    mutation CreateReferralType($input: ReferralTypeInput!) {
  createReferralType(input: $input)
}
    `;
/**
 * __useCreateReferralTypeMutation__
 *
 * To run a mutation, you first call `useCreateReferralTypeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateReferralTypeMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createReferralTypeMutation, { data, loading, error }] = useCreateReferralTypeMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateReferralTypeMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateReferralTypeDocument, options);
}
export const CreateTierDocument = gql `
    mutation CreateTier($input: TierInput!) {
  createTier(input: $input)
}
    `;
/**
 * __useCreateTierMutation__
 *
 * To run a mutation, you first call `useCreateTierMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateTierMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createTierMutation, { data, loading, error }] = useCreateTierMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateTierMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(CreateTierDocument, options);
}
export const RegenerateOpportunityPayloadSecretKeyDocument = gql `
    mutation RegenerateOpportunityPayloadSecretKey($id: ID!) {
  regenerateOpportunityPayloadSecretKey(id: $id)
}
    `;
/**
 * __useRegenerateOpportunityPayloadSecretKeyMutation__
 *
 * To run a mutation, you first call `useRegenerateOpportunityPayloadSecretKeyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRegenerateOpportunityPayloadSecretKeyMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [regenerateOpportunityPayloadSecretKeyMutation, { data, loading, error }] = useRegenerateOpportunityPayloadSecretKeyMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useRegenerateOpportunityPayloadSecretKeyMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(RegenerateOpportunityPayloadSecretKeyDocument, options);
}
export const RemoveInviteCodeDocument = gql `
    mutation RemoveInviteCode($inviteCode: String!) {
  removeInviteCode(inviteCode: $inviteCode)
}
    `;
/**
 * __useRemoveInviteCodeMutation__
 *
 * To run a mutation, you first call `useRemoveInviteCodeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveInviteCodeMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [removeInviteCodeMutation, { data, loading, error }] = useRemoveInviteCodeMutation({
 *   variables: {
 *      inviteCode: // value for 'inviteCode'
 *   },
 * });
 */
export function useRemoveInviteCodeMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(RemoveInviteCodeDocument, options);
}
export const RevokeCompanyTokenDocument = gql `
    mutation RevokeCompanyToken($authToken: String!) {
  revokeCompanyToken(authToken: $authToken)
}
    `;
/**
 * __useRevokeCompanyTokenMutation__
 *
 * To run a mutation, you first call `useRevokeCompanyTokenMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRevokeCompanyTokenMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [revokeCompanyTokenMutation, { data, loading, error }] = useRevokeCompanyTokenMutation({
 *   variables: {
 *      authToken: // value for 'authToken'
 *   },
 * });
 */
export function useRevokeCompanyTokenMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(RevokeCompanyTokenDocument, options);
}
export const TriggerOpportunityNotificationDocument = gql `
    mutation TriggerOpportunityNotification($opportunityId: ID!) {
  triggerOpportunityNotification(opportunityId: $opportunityId)
}
    `;
/**
 * __useTriggerOpportunityNotificationMutation__
 *
 * To run a mutation, you first call `useTriggerOpportunityNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useTriggerOpportunityNotificationMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [triggerOpportunityNotificationMutation, { data, loading, error }] = useTriggerOpportunityNotificationMutation({
 *   variables: {
 *      opportunityId: // value for 'opportunityId'
 *   },
 * });
 */
export function useTriggerOpportunityNotificationMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(TriggerOpportunityNotificationDocument, options);
}
export const UpdateLeaderboardProjectHiddenStatusDocument = gql `
    mutation UpdateLeaderboardProjectHiddenStatus($id: String!, $hidden: Boolean!) {
  updateLeaderboardProjectHiddenStatus(id: $id, hidden: $hidden)
}
    `;
/**
 * __useUpdateLeaderboardProjectHiddenStatusMutation__
 *
 * To run a mutation, you first call `useUpdateLeaderboardProjectHiddenStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateLeaderboardProjectHiddenStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateLeaderboardProjectHiddenStatusMutation, { data, loading, error }] = useUpdateLeaderboardProjectHiddenStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      hidden: // value for 'hidden'
 *   },
 * });
 */
export function useUpdateLeaderboardProjectHiddenStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateLeaderboardProjectHiddenStatusDocument, options);
}
export const UpdateAirdropDocument = gql `
    mutation UpdateAirdrop($id: ID!, $input: AdminAirdropInput!, $file: Upload) {
  updateAirdrop(id: $id, file: $file, input: $input)
}
    `;
/**
 * __useUpdateAirdropMutation__
 *
 * To run a mutation, you first call `useUpdateAirdropMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateAirdropMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateAirdropMutation, { data, loading, error }] = useUpdateAirdropMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *      file: // value for 'file'
 *   },
 * });
 */
export function useUpdateAirdropMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateAirdropDocument, options);
}
export const UpdateBrandDocument = gql `
    mutation updateBrand($id: ID!, $input: BrandInput!, $file: Upload) {
  updateBrand(id: $id, file: $file, input: $input)
}
    `;
/**
 * __useUpdateBrandMutation__
 *
 * To run a mutation, you first call `useUpdateBrandMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateBrandMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateBrandMutation, { data, loading, error }] = useUpdateBrandMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *      file: // value for 'file'
 *   },
 * });
 */
export function useUpdateBrandMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateBrandDocument, options);
}
export const UpdateBrandArchivedStatusDocument = gql `
    mutation UpdateBrandArchivedStatus($id: ID!, $isArchived: Boolean!) {
  updateBrandArchivedStatus(id: $id, isArchived: $isArchived)
}
    `;
/**
 * __useUpdateBrandArchivedStatusMutation__
 *
 * To run a mutation, you first call `useUpdateBrandArchivedStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateBrandArchivedStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateBrandArchivedStatusMutation, { data, loading, error }] = useUpdateBrandArchivedStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      isArchived: // value for 'isArchived'
 *   },
 * });
 */
export function useUpdateBrandArchivedStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateBrandArchivedStatusDocument, options);
}
export const UpdateCategoryDocument = gql `
    mutation updateCategory($id: ID!, $input: CategoryInput!) {
  updateCategory(id: $id, input: $input)
}
    `;
/**
 * __useUpdateCategoryMutation__
 *
 * To run a mutation, you first call `useUpdateCategoryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateCategoryMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateCategoryMutation, { data, loading, error }] = useUpdateCategoryMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateCategoryMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateCategoryDocument, options);
}
export const UpdateCategoryArchivedStatusDocument = gql `
    mutation UpdateCategoryArchivedStatus($id: ID!, $isArchived: Boolean!) {
  updateCategoryArchivedStatus(id: $id, isArchived: $isArchived)
}
    `;
/**
 * __useUpdateCategoryArchivedStatusMutation__
 *
 * To run a mutation, you first call `useUpdateCategoryArchivedStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateCategoryArchivedStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateCategoryArchivedStatusMutation, { data, loading, error }] = useUpdateCategoryArchivedStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      isArchived: // value for 'isArchived'
 *   },
 * });
 */
export function useUpdateCategoryArchivedStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateCategoryArchivedStatusDocument, options);
}
export const UpdateCompanyTokenRateLimitsDocument = gql `
    mutation UpdateCompanyTokenRateLimits($jti: String!, $input: RateLimitsInput!) {
  updateCompanyTokenRateLimits(jti: $jti, input: $input)
}
    `;
/**
 * __useUpdateCompanyTokenRateLimitsMutation__
 *
 * To run a mutation, you first call `useUpdateCompanyTokenRateLimitsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateCompanyTokenRateLimitsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateCompanyTokenRateLimitsMutation, { data, loading, error }] = useUpdateCompanyTokenRateLimitsMutation({
 *   variables: {
 *      jti: // value for 'jti'
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateCompanyTokenRateLimitsMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateCompanyTokenRateLimitsDocument, options);
}
export const UpdateInviteCodeUsagesLimitDocument = gql `
    mutation UpdateInviteCodeUsagesLimit($code: String!, $usagesLimit: Int!) {
  updateInviteCodeUsagesLimit(code: $code, usagesLimit: $usagesLimit)
}
    `;
/**
 * __useUpdateInviteCodeUsagesLimitMutation__
 *
 * To run a mutation, you first call `useUpdateInviteCodeUsagesLimitMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateInviteCodeUsagesLimitMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateInviteCodeUsagesLimitMutation, { data, loading, error }] = useUpdateInviteCodeUsagesLimitMutation({
 *   variables: {
 *      code: // value for 'code'
 *      usagesLimit: // value for 'usagesLimit'
 *   },
 * });
 */
export function useUpdateInviteCodeUsagesLimitMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateInviteCodeUsagesLimitDocument, options);
}
export const UpdateKpiSettingsDocument = gql `
    mutation UpdateKPISettings($input: ProjectsKPISettingsInput!) {
  updateKPISettings(input: $input)
}
    `;
/**
 * __useUpdateKpiSettingsMutation__
 *
 * To run a mutation, you first call `useUpdateKpiSettingsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateKpiSettingsMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateKpiSettingsMutation, { data, loading, error }] = useUpdateKpiSettingsMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateKpiSettingsMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateKpiSettingsDocument, options);
}
export const UpdateLeaderboardDocument = gql `
    mutation UpdateLeaderboard($type: LeaderboardType!, $input: LeaderboardInput!) {
  updateLeaderboard(type: $type, input: $input)
}
    `;
/**
 * __useUpdateLeaderboardMutation__
 *
 * To run a mutation, you first call `useUpdateLeaderboardMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateLeaderboardMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateLeaderboardMutation, { data, loading, error }] = useUpdateLeaderboardMutation({
 *   variables: {
 *      type: // value for 'type'
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateLeaderboardMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateLeaderboardDocument, options);
}
export const UpdateOpportunityDocument = gql `
    mutation updateOpportunity($id: ID!, $input: AdminOpportunityInput!, $file: Upload) {
  updateOpportunity(id: $id, file: $file, input: $input)
}
    `;
/**
 * __useUpdateOpportunityMutation__
 *
 * To run a mutation, you first call `useUpdateOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateOpportunityMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateOpportunityMutation, { data, loading, error }] = useUpdateOpportunityMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *      file: // value for 'file'
 *   },
 * });
 */
export function useUpdateOpportunityMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateOpportunityDocument, options);
}
export const UpdateOpportunityArchivedStatusDocument = gql `
    mutation UpdateOpportunityArchivedStatus($id: ID!, $isArchived: Boolean!) {
  updateOpportunityArchivedStatus(id: $id, isArchived: $isArchived)
}
    `;
/**
 * __useUpdateOpportunityArchivedStatusMutation__
 *
 * To run a mutation, you first call `useUpdateOpportunityArchivedStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateOpportunityArchivedStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateOpportunityArchivedStatusMutation, { data, loading, error }] = useUpdateOpportunityArchivedStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      isArchived: // value for 'isArchived'
 *   },
 * });
 */
export function useUpdateOpportunityArchivedStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateOpportunityArchivedStatusDocument, options);
}
export const UpdateOpportunityPushStatusDocument = gql `
    mutation UpdateOpportunityPushStatus($opportunityId: ID!, $isActive: Boolean!) {
  updateOpportunityPushStatus(opportunityId: $opportunityId, isActive: $isActive)
}
    `;
/**
 * __useUpdateOpportunityPushStatusMutation__
 *
 * To run a mutation, you first call `useUpdateOpportunityPushStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateOpportunityPushStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateOpportunityPushStatusMutation, { data, loading, error }] = useUpdateOpportunityPushStatusMutation({
 *   variables: {
 *      opportunityId: // value for 'opportunityId'
 *      isActive: // value for 'isActive'
 *   },
 * });
 */
export function useUpdateOpportunityPushStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateOpportunityPushStatusDocument, options);
}
export const UpdateProfileStatusDocument = gql `
    mutation UpdateProfileStatus($userId: ID!, $isActive: Boolean!) {
  updateProfileStatus(userId: $userId, isActive: $isActive)
}
    `;
/**
 * __useUpdateProfileStatusMutation__
 *
 * To run a mutation, you first call `useUpdateProfileStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateProfileStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateProfileStatusMutation, { data, loading, error }] = useUpdateProfileStatusMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *      isActive: // value for 'isActive'
 *   },
 * });
 */
export function useUpdateProfileStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateProfileStatusDocument, options);
}
export const UpdateProjectDocument = gql `
    mutation UpdateProject($input: AdminProjectInput!) {
  updateProject(input: $input)
}
    `;
/**
 * __useUpdateProjectMutation__
 *
 * To run a mutation, you first call `useUpdateProjectMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateProjectMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateProjectMutation, { data, loading, error }] = useUpdateProjectMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateProjectMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateProjectDocument, options);
}
export const UpdatePublisherDocument = gql `
    mutation UpdatePublisher($input: PublisherInput!) {
  updatePublisher(input: $input)
}
    `;
/**
 * __useUpdatePublisherMutation__
 *
 * To run a mutation, you first call `useUpdatePublisherMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdatePublisherMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updatePublisherMutation, { data, loading, error }] = useUpdatePublisherMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdatePublisherMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdatePublisherDocument, options);
}
export const UpdateReferralTypeDocument = gql `
    mutation UpdateReferralType($id: ID!, $input: ReferralTypeInput!) {
  updateReferralType(id: $id, input: $input)
}
    `;
/**
 * __useUpdateReferralTypeMutation__
 *
 * To run a mutation, you first call `useUpdateReferralTypeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateReferralTypeMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateReferralTypeMutation, { data, loading, error }] = useUpdateReferralTypeMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateReferralTypeMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateReferralTypeDocument, options);
}
export const UpdateReferralTypeArchivedStatusDocument = gql `
    mutation UpdateReferralTypeArchivedStatus($id: ID!, $isArchived: Boolean!) {
  updateReferralTypeArchivedStatus(id: $id, archived: $isArchived)
}
    `;
/**
 * __useUpdateReferralTypeArchivedStatusMutation__
 *
 * To run a mutation, you first call `useUpdateReferralTypeArchivedStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateReferralTypeArchivedStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateReferralTypeArchivedStatusMutation, { data, loading, error }] = useUpdateReferralTypeArchivedStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      isArchived: // value for 'isArchived'
 *   },
 * });
 */
export function useUpdateReferralTypeArchivedStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateReferralTypeArchivedStatusDocument, options);
}
export const UpdateTierDocument = gql `
    mutation UpdateTier($id: ID!, $input: TierInput!) {
  updateTier(id: $id, input: $input)
}
    `;
/**
 * __useUpdateTierMutation__
 *
 * To run a mutation, you first call `useUpdateTierMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateTierMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateTierMutation, { data, loading, error }] = useUpdateTierMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateTierMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateTierDocument, options);
}
export const UpdateTierArchivedStatusDocument = gql `
    mutation UpdateTierArchivedStatus($id: ID!, $isArchived: Boolean!) {
  updateTierArchivedStatus(id: $id, isArchived: $isArchived)
}
    `;
/**
 * __useUpdateTierArchivedStatusMutation__
 *
 * To run a mutation, you first call `useUpdateTierArchivedStatusMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateTierArchivedStatusMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateTierArchivedStatusMutation, { data, loading, error }] = useUpdateTierArchivedStatusMutation({
 *   variables: {
 *      id: // value for 'id'
 *      isArchived: // value for 'isArchived'
 *   },
 * });
 */
export function useUpdateTierArchivedStatusMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateTierArchivedStatusDocument, options);
}
export const CheckInviteCodeDocument = gql `
    query CheckInviteCode($code: String!) {
  checkInviteCode(code: $code) {
    code
    isAvailable
    usedTimes
    maxUsagesLimit
  }
}
    `;
/**
 * __useCheckInviteCodeQuery__
 *
 * To run a query within a React component, call `useCheckInviteCodeQuery` and pass it any options that fit your needs.
 * When your component renders, `useCheckInviteCodeQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useCheckInviteCodeQuery({
 *   variables: {
 *      code: // value for 'code'
 *   },
 * });
 */
export function useCheckInviteCodeQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(CheckInviteCodeDocument, options);
}
export function useCheckInviteCodeLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(CheckInviteCodeDocument, options);
}
export function useCheckInviteCodeSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(CheckInviteCodeDocument, options);
}
export const FetchAdminAirdropsPageDocument = gql `
    query FetchAdminAirdropsPage($filter: AirdropsLeaderboardFilterInput!, $sort: AirdropsLeaderboardSortInput, $page: AdminPageInput!) {
  fetchAdminAirdropsPage(filter: $filter, sort: $sort, page: $page) {
    opportunities {
      opportunityId
      name
      description
      projectName
      industry
      category
      ludoUrl
      projectUrl
      pushNotificationsEnabled
      status
      activeFrom
      activeUntil
      minXpLevel
      maxXpLevel
      minLudoRank
      maxLudoRank
      media
      minWalletValue
      maxWalletValue
      clicks
      views
      addedBy
      archived
      blockchains
      geolocations
      notificationDestinations
      type
      devicePlatforms
      participants
      hidden
      showcase
      participantsLimit
      availablePlacesForAirdrop
      encodePayload
      payloadTypes
      parentOpportunityId
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchAdminAirdropsPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminAirdropsPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminAirdropsPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminAirdropsPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminAirdropsPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminAirdropsPageDocument, options);
}
export function useFetchAdminAirdropsPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminAirdropsPageDocument, options);
}
export function useFetchAdminAirdropsPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminAirdropsPageDocument, options);
}
export const FetchAdminBrandsDocument = gql `
    query FetchAdminBrands {
  fetchAdminBrands {
    id
    name
  }
}
    `;
/**
 * __useFetchAdminBrandsQuery__
 *
 * To run a query within a React component, call `useFetchAdminBrandsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminBrandsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminBrandsQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchAdminBrandsQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminBrandsDocument, options);
}
export function useFetchAdminBrandsLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminBrandsDocument, options);
}
export function useFetchAdminBrandsSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminBrandsDocument, options);
}
export const FetchAdminBrandsPageDocument = gql `
    query FetchAdminBrandsPage($filter: BrandsFilterInput!, $sort: BrandsSortInput!, $page: AdminPageInput!) {
  fetchAdminBrandsPage(filter: $filter, sort: $sort, page: $page) {
    brands {
      description
      id
      industry
      link
      matchingWords
      media
      name
      archived
      addedBy
      discord
      telegram
      twitter
      facebook
      linkedin
      youtube
      referralLinks {
        referralUrl
        numOfReferredIps
        numOfReferredUsers
        refcode
        reftypeId
        reftypeName
        reftypeColor
        maxUsagesLimit
      }
      slug
    }
    nextPage {
      num
      lastNum
      size
      elements
    }
  }
}
    `;
/**
 * __useFetchAdminBrandsPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminBrandsPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminBrandsPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminBrandsPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminBrandsPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminBrandsPageDocument, options);
}
export function useFetchAdminBrandsPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminBrandsPageDocument, options);
}
export function useFetchAdminBrandsPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminBrandsPageDocument, options);
}
export const FetchAdminCategoriesDocument = gql `
    query FetchAdminCategories {
  fetchAdminCategories {
    id
    name
  }
}
    `;
/**
 * __useFetchAdminCategoriesQuery__
 *
 * To run a query within a React component, call `useFetchAdminCategoriesQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminCategoriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminCategoriesQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchAdminCategoriesQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminCategoriesDocument, options);
}
export function useFetchAdminCategoriesLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminCategoriesDocument, options);
}
export function useFetchAdminCategoriesSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminCategoriesDocument, options);
}
export const FetchAdminCategoriesPageDocument = gql `
    query FetchAdminCategoriesPage($filter: CategoriesFilterInput!, $sort: CategoriesSortInput!, $page: AdminPageInput!) {
  fetchAdminCategoriesPage(filter: $filter, sort: $sort, page: $page) {
    categories {
      id
      name
      matchingWords
      archived
      addedBy
    }
    nextPage {
      num
      lastNum
      size
      elements
    }
  }
}
    `;
/**
 * __useFetchAdminCategoriesPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminCategoriesPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminCategoriesPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminCategoriesPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminCategoriesPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminCategoriesPageDocument, options);
}
export function useFetchAdminCategoriesPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminCategoriesPageDocument, options);
}
export function useFetchAdminCategoriesPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminCategoriesPageDocument, options);
}
export const FetchAdminInvitesPageDocument = gql `
    query fetchAdminInvitesPage($filter: InvitesFilterInput!, $sort: InvitesSortInput!, $page: AdminPageInput!) {
  fetchAdminInvitesPage(filter: $filter, sort: $sort, page: $page) {
    invites {
      userId
      username
      wallet {
        address
        blockchain
        chainId
      }
      activeInvites {
        inviteCode
        createdAt
        usedTimes
        maxUsagesLimit
        reftypeId
        reftypeName
        reftypeColor
      }
      referredUsers
      userXpLevel
      profileLink {
        referralUrl
        numOfReferredIps
        numOfReferredUsers
        refcode
        reftypeId
        reftypeName
        reftypeColor
        maxUsagesLimit
      }
    }
    nextPage {
      num
      lastNum
      size
      elements
      token
    }
  }
}
    `;
/**
 * __useFetchAdminInvitesPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminInvitesPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminInvitesPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminInvitesPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminInvitesPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminInvitesPageDocument, options);
}
export function useFetchAdminInvitesPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminInvitesPageDocument, options);
}
export function useFetchAdminInvitesPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminInvitesPageDocument, options);
}
export const FetchAdminOpportunitiesByTypeDocument = gql `
    query FetchAdminOpportunitiesByType($type: OpportunityType!) {
  fetchAdminOpportunitiesByType(type: $type) {
    opportunityId
    name
  }
}
    `;
/**
 * __useFetchAdminOpportunitiesByTypeQuery__
 *
 * To run a query within a React component, call `useFetchAdminOpportunitiesByTypeQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminOpportunitiesByTypeQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminOpportunitiesByTypeQuery({
 *   variables: {
 *      type: // value for 'type'
 *   },
 * });
 */
export function useFetchAdminOpportunitiesByTypeQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminOpportunitiesByTypeDocument, options);
}
export function useFetchAdminOpportunitiesByTypeLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminOpportunitiesByTypeDocument, options);
}
export function useFetchAdminOpportunitiesByTypeSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminOpportunitiesByTypeDocument, options);
}
export const FetchAdminOpportunitiesPageDocument = gql `
    query FetchAdminOpportunitiesPage($filter: OpportunitiesFilterInput!, $sort: OpportunitiesSortInput!, $page: AdminPageInput!) {
  fetchAdminOpportunitiesPage(filter: $filter, sort: $sort, page: $page) {
    opportunities {
      opportunityId
      name
      projectName
      industry
      category
      ludoUrl
      projectUrl
      pushNotificationsEnabled
      status
      media
      description
      activeFrom
      activeUntil
      minXpLevel
      maxXpLevel
      minLudoRank
      maxLudoRank
      minWalletValue
      maxWalletValue
      clicks
      views
      addedBy
      archived
      blockchains
      geolocations
      notificationDestinations
      type
      devicePlatforms
      participantsLimit
      availablePlacesForAirdrop
      encodePayload
      payloadTypes
      parentOpportunityId
      slug
      payloadSecretKey
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchAdminOpportunitiesPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminOpportunitiesPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminOpportunitiesPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminOpportunitiesPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminOpportunitiesPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminOpportunitiesPageDocument, options);
}
export function useFetchAdminOpportunitiesPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminOpportunitiesPageDocument, options);
}
export function useFetchAdminOpportunitiesPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminOpportunitiesPageDocument, options);
}
export const FetchAdminProjectsDocument = gql `
    query FetchAdminProjects {
  fetchAdminProjects {
    id
    name
  }
}
    `;
/**
 * __useFetchAdminProjectsQuery__
 *
 * To run a query within a React component, call `useFetchAdminProjectsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminProjectsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminProjectsQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchAdminProjectsQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminProjectsDocument, options);
}
export function useFetchAdminProjectsLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminProjectsDocument, options);
}
export function useFetchAdminProjectsSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminProjectsDocument, options);
}
export const FetchAdminProjectsPageDocument = gql `
    query FetchAdminProjectsPage($filter: AdminProjectsFilterInput!, $sort: AdminProjectsSortInput!, $page: AdminPageInput!) {
  fetchProjectsPage(filter: $filter, sort: $sort, page: $page) {
    projects {
      id
      blockchain
      contract
      name
      verified
      hidden
      price
      priceDayDifference
      rank
      rankDayDifference
      holders
      holdersDayDifference
      twitterFollowers
      twitterFollowersDayDifference
      website
      websiteRank
      twitter
      hideDiagrams
      slug
      fetchedAt
      reactions {
        likes
        neutrals
        dislikes
      }
      removalReason
      removalDate
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchAdminProjectsPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminProjectsPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminProjectsPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminProjectsPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminProjectsPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminProjectsPageDocument, options);
}
export function useFetchAdminProjectsPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminProjectsPageDocument, options);
}
export function useFetchAdminProjectsPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminProjectsPageDocument, options);
}
export const FetchAdminReferralsPageDocument = gql `
    query FetchAdminReferralsPage($filter: ReferralsFilterInput!, $sort: ReferralsSortInput!, $page: AdminPageInput!) {
  fetchAdminReferralsPage(filter: $filter, sort: $sort, page: $page) {
    adminReferrals {
      userId
      username
      mainWallet {
        address
        blockchain
        chainId
      }
      referredUsersNum
      referrals {
        userRefUrl
        opportunityUrl
        referredUsersPerUrlNum
      }
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchAdminReferralsPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminReferralsPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminReferralsPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminReferralsPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminReferralsPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminReferralsPageDocument, options);
}
export function useFetchAdminReferralsPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminReferralsPageDocument, options);
}
export function useFetchAdminReferralsPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminReferralsPageDocument, options);
}
export const FetchAdminUsersPageDocument = gql `
    query fetchAdminUsersPage($filter: UsersFilterInput!, $sort: UsersSortInput!, $page: AdminPageInput!) {
  fetchAdminUsersPage(filter: $filter, sort: $sort, page: $page) {
    users {
      userId
      username
      wallets {
        address
        blockchain
        chainId
      }
      connectedBlockchains
      isActive
      createdAt
      topInterests
      walletsValue
      xpLevel
      ludoRank
      inviterId
      ip
      location
      userLanguage
      devicePlatform
      firstVisitSource
      lastLoggedAt
    }
    nextPage {
      num
      lastNum
      size
      elements
      token
    }
  }
}
    `;
/**
 * __useFetchAdminUsersPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminUsersPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminUsersPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminUsersPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminUsersPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminUsersPageDocument, options);
}
export function useFetchAdminUsersPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminUsersPageDocument, options);
}
export function useFetchAdminUsersPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminUsersPageDocument, options);
}
export const FetchAdminXpPageDocument = gql `
    query FetchAdminXpPage($filter: XpFilterInput!, $sort: XpSortInput!, $page: AdminPageInput!) {
  fetchAdminXpPage(filter: $filter, sort: $sort, page: $page) {
    xps {
      userId
      username
      mainWallet {
        address
        blockchain
        chainId
      }
      userXpLevel
      userXpPoints
      referredUsers
      referredUsersNum
      joinedOpportunityIds
      connectedWalletsNum
      suggestedOpportunityIds
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchAdminXpPageQuery__
 *
 * To run a query within a React component, call `useFetchAdminXpPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAdminXpPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAdminXpPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAdminXpPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAdminXpPageDocument, options);
}
export function useFetchAdminXpPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAdminXpPageDocument, options);
}
export function useFetchAdminXpPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAdminXpPageDocument, options);
}
export const FetchAlertingPageDocument = gql `
    query FetchAlertingPage($filter: AdminProjectsAlertingFilterInput!, $sort: AdminProjectsAlertingSortInput!, $page: AdminPageInput!) {
  fetchAlertingPage(filter: $filter, sort: $sort, page: $page) {
    projectsAlerting {
      userId
      slotsFree
      slotsLimit
      activeUntil
      featurePackId
      featurePackName
      wallets {
        address
        blockchain
        chainId
      }
      projects {
        blockchain
        contract
        name
      }
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchAlertingPageQuery__
 *
 * To run a query within a React component, call `useFetchAlertingPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAlertingPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAlertingPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchAlertingPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAlertingPageDocument, options);
}
export function useFetchAlertingPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAlertingPageDocument, options);
}
export function useFetchAlertingPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAlertingPageDocument, options);
}
export const FetchAllCountriesDocument = gql `
    query FetchAllCountries {
  fetchAllCountries {
    continent
    country
  }
}
    `;
/**
 * __useFetchAllCountriesQuery__
 *
 * To run a query within a React component, call `useFetchAllCountriesQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAllCountriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchAllCountriesQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchAllCountriesQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchAllCountriesDocument, options);
}
export function useFetchAllCountriesLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchAllCountriesDocument, options);
}
export function useFetchAllCountriesSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchAllCountriesDocument, options);
}
export const FetchBlockchainsDocument = gql `
    query FetchBlockchains {
  fetchBlockchains
}
    `;
/**
 * __useFetchBlockchainsQuery__
 *
 * To run a query within a React component, call `useFetchBlockchainsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchBlockchainsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchBlockchainsQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchBlockchainsQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchBlockchainsDocument, options);
}
export function useFetchBlockchainsLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchBlockchainsDocument, options);
}
export function useFetchBlockchainsSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchBlockchainsDocument, options);
}
export const FetchCompanyTokensPageDocument = gql `
    query FetchCompanyTokensPage($filter: CompanyTokensFilterInput!, $page: AdminPageInput!) {
  fetchCompanyTokensPage(filter: $filter, page: $page) {
    companyTokens {
      jti
      companyName
      authToken
      tariffPlan
      authorities
      issuedAt
      expiredAt
      requestsPerSecond
      requestsPerMinute
      requestsPerHour
      requestsPerDay
      computingUnits
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchCompanyTokensPageQuery__
 *
 * To run a query within a React component, call `useFetchCompanyTokensPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchCompanyTokensPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchCompanyTokensPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchCompanyTokensPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchCompanyTokensPageDocument, options);
}
export function useFetchCompanyTokensPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchCompanyTokensPageDocument, options);
}
export function useFetchCompanyTokensPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchCompanyTokensPageDocument, options);
}
export const FetchContactSupportPageDocument = gql `
    query FetchContactSupportPage($filter: ContactSupportFilterInput!, $sort: ContactSupportSortInput!, $page: AdminPageInput!) {
  fetchContactSupportPage(filter: $filter, sort: $sort, page: $page) {
    contactSupports {
      userId
      id
      email
      walletAddress
      category
      description
      priority
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchContactSupportPageQuery__
 *
 * To run a query within a React component, call `useFetchContactSupportPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchContactSupportPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchContactSupportPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchContactSupportPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchContactSupportPageDocument, options);
}
export function useFetchContactSupportPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchContactSupportPageDocument, options);
}
export function useFetchContactSupportPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchContactSupportPageDocument, options);
}
export const FetchContentReportPageDocument = gql `
    query FetchContentReportPage($filter: ContentReportFilterInput!, $sort: ContentReportSortInput!, $page: AdminPageInput!) {
  fetchContentReportPage(filter: $filter, sort: $sort, page: $page) {
    contentReports {
      userId
      id
      email
      description
      nameOfSubject
      contentType
      contentId
      reportReason
      evidenceFileUrl
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchContentReportPageQuery__
 *
 * To run a query within a React component, call `useFetchContentReportPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchContentReportPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchContentReportPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchContentReportPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchContentReportPageDocument, options);
}
export function useFetchContentReportPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchContentReportPageDocument, options);
}
export function useFetchContentReportPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchContentReportPageDocument, options);
}
export const FetchDefaultRateLimitsDocument = gql `
    query FetchDefaultRateLimits($tariffPlan: TariffPlan!) {
  fetchDefaultRateLimits(tariffPlan: $tariffPlan) {
    requestsPerSecond
    requestsPerMinute
    requestsPerHour
    requestsPerDay
    computingUnits
  }
}
    `;
/**
 * __useFetchDefaultRateLimitsQuery__
 *
 * To run a query within a React component, call `useFetchDefaultRateLimitsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchDefaultRateLimitsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchDefaultRateLimitsQuery({
 *   variables: {
 *      tariffPlan: // value for 'tariffPlan'
 *   },
 * });
 */
export function useFetchDefaultRateLimitsQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchDefaultRateLimitsDocument, options);
}
export function useFetchDefaultRateLimitsLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchDefaultRateLimitsDocument, options);
}
export function useFetchDefaultRateLimitsSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchDefaultRateLimitsDocument, options);
}
export const FetchFeaturePackPurchasePageDocument = gql `
    query fetchFeaturePackPurchasePage($filter: FeaturePackPurchaseFilterInput!, $sort: FeaturePackPurchaseSortInput!, $page: AdminPageInput!) {
  fetchFeaturePackPurchasePage(filter: $filter, sort: $sort, page: $page) {
    purchases {
      userId
      username
      price
      purchasePrice
      featurePackId
      featurePackName
      purchaseType
      purchasedAt
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
    priceSum
    purchasePriceSum
  }
}
    `;
/**
 * __useFetchFeaturePackPurchasePageQuery__
 *
 * To run a query within a React component, call `useFetchFeaturePackPurchasePageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchFeaturePackPurchasePageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchFeaturePackPurchasePageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchFeaturePackPurchasePageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchFeaturePackPurchasePageDocument, options);
}
export function useFetchFeaturePackPurchasePageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchFeaturePackPurchasePageDocument, options);
}
export function useFetchFeaturePackPurchasePageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchFeaturePackPurchasePageDocument, options);
}
export const FetchFeaturePackPurchasesCsvDocument = gql `
    query fetchFeaturePackPurchasesCsv($filter: FeaturePackPurchaseFilterInput!, $sort: FeaturePackPurchaseSortInput!) {
  fetchFeaturePackPurchasesCsv(filter: $filter, sort: $sort)
}
    `;
/**
 * __useFetchFeaturePackPurchasesCsvQuery__
 *
 * To run a query within a React component, call `useFetchFeaturePackPurchasesCsvQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchFeaturePackPurchasesCsvQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchFeaturePackPurchasesCsvQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *   },
 * });
 */
export function useFetchFeaturePackPurchasesCsvQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchFeaturePackPurchasesCsvDocument, options);
}
export function useFetchFeaturePackPurchasesCsvLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchFeaturePackPurchasesCsvDocument, options);
}
export function useFetchFeaturePackPurchasesCsvSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchFeaturePackPurchasesCsvDocument, options);
}
export const FetchFormOpportunityPageDocument = gql `
    query FetchFormOpportunityPage($filter: FormOpportunityFilterInput!, $sort: FormOpportunitySortInput!, $page: AdminPageInput!) {
  fetchFormOpportunityPage(filter: $filter, sort: $sort, page: $page) {
    opportunities {
      userId
      id
      name
      submitterEmail
      description
      registrationLink
      startDate
      endDate
      blockchain
      opportunityType
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchFormOpportunityPageQuery__
 *
 * To run a query within a React component, call `useFetchFormOpportunityPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchFormOpportunityPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchFormOpportunityPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchFormOpportunityPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchFormOpportunityPageDocument, options);
}
export function useFetchFormOpportunityPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchFormOpportunityPageDocument, options);
}
export function useFetchFormOpportunityPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchFormOpportunityPageDocument, options);
}
export const FetchInvestorInquiryPageDocument = gql `
    query FetchInvestorInquiryPage($filter: InvestorInquiryFilterInput!, $sort: InvestorInquirySortInput!, $page: AdminPageInput!) {
  fetchInvestorInquiryPage(filter: $filter, sort: $sort, page: $page) {
    investorInquiries {
      userId
      id
      email
      name
      phoneNumber
      telegramId
      investorType
      investmentAmount
      investmentExperience
      assistanceRequest
      ludoReferrerInfo
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchInvestorInquiryPageQuery__
 *
 * To run a query within a React component, call `useFetchInvestorInquiryPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchInvestorInquiryPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchInvestorInquiryPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchInvestorInquiryPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchInvestorInquiryPageDocument, options);
}
export function useFetchInvestorInquiryPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchInvestorInquiryPageDocument, options);
}
export function useFetchInvestorInquiryPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchInvestorInquiryPageDocument, options);
}
export const FetchLeaderboardDocument = gql `
    query FetchLeaderboard($type: LeaderboardType!) {
  fetchLeaderboard(type: $type) {
    type
    accessType
    minRank
    maxRank
    minXpLevel
    maxXpLevel
    geolocations
    hidden
  }
}
    `;
/**
 * __useFetchLeaderboardQuery__
 *
 * To run a query within a React component, call `useFetchLeaderboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchLeaderboardQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchLeaderboardQuery({
 *   variables: {
 *      type: // value for 'type'
 *   },
 * });
 */
export function useFetchLeaderboardQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchLeaderboardDocument, options);
}
export function useFetchLeaderboardLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchLeaderboardDocument, options);
}
export function useFetchLeaderboardSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchLeaderboardDocument, options);
}
export const FetchLeaderboardProjectsPageDocument = gql `
    query FetchLeaderboardProjectsPage($filter: AdminLeaderboardProjectsFilterInput!, $sort: AdminLeaderboardProjectsSortInput!, $page: AdminPageInput!) {
  fetchLeaderboardProjectsPage(filter: $filter, sort: $sort, page: $page) {
    projects {
      id
      name
      rank
      rankHourDifference
      rankDayDifference
      rankWeekDifference
      price
      showcase
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchLeaderboardProjectsPageQuery__
 *
 * To run a query within a React component, call `useFetchLeaderboardProjectsPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchLeaderboardProjectsPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchLeaderboardProjectsPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchLeaderboardProjectsPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchLeaderboardProjectsPageDocument, options);
}
export function useFetchLeaderboardProjectsPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchLeaderboardProjectsPageDocument, options);
}
export function useFetchLeaderboardProjectsPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchLeaderboardProjectsPageDocument, options);
}
export const FetchMonitoringPageDocument = gql `
    query FetchMonitoringPage($filter: AdminProjectsMonitoringFilterInput!, $sort: AdminProjectsMonitoringSortInput!, $page: AdminPageInput!) {
  fetchMonitoringPage(filter: $filter, sort: $sort, page: $page) {
    projectsMonitoring {
      userId
      username
      monitorsFree
      monitorsLimit
      activationMethod
      activeUntil
      wallets {
        address
        blockchain
        chainId
        isMain
      }
      projects {
        blockchain
        contract
        name
      }
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchMonitoringPageQuery__
 *
 * To run a query within a React component, call `useFetchMonitoringPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchMonitoringPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchMonitoringPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchMonitoringPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchMonitoringPageDocument, options);
}
export function useFetchMonitoringPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchMonitoringPageDocument, options);
}
export function useFetchMonitoringPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchMonitoringPageDocument, options);
}
export const FetchPartnershipInquiryPageDocument = gql `
    query FetchPartnershipInquiryPage($filter: PartnershipInquiryFilterInput!, $sort: PartnershipInquirySortInput!, $page: AdminPageInput!) {
  fetchPartnershipInquiryPage(filter: $filter, sort: $sort, page: $page) {
    partnershipInquiries {
      userId
      id
      email
      name
      projectName
      website
      aboutProject
      partnershipType
      ludoReferrerInfo
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchPartnershipInquiryPageQuery__
 *
 * To run a query within a React component, call `useFetchPartnershipInquiryPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchPartnershipInquiryPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchPartnershipInquiryPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchPartnershipInquiryPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchPartnershipInquiryPageDocument, options);
}
export function useFetchPartnershipInquiryPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchPartnershipInquiryPageDocument, options);
}
export function useFetchPartnershipInquiryPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchPartnershipInquiryPageDocument, options);
}
export const FetchProjectAirdropRegistrationsInfoCsvDocument = gql `
    query FetchProjectAirdropRegistrationsInfoCsv($blockchain: String!, $contract: String!) {
  fetchProjectAirdropRegistrationsInfoCsv(
    blockchain: $blockchain
    contract: $contract
  )
}
    `;
/**
 * __useFetchProjectAirdropRegistrationsInfoCsvQuery__
 *
 * To run a query within a React component, call `useFetchProjectAirdropRegistrationsInfoCsvQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchProjectAirdropRegistrationsInfoCsvQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchProjectAirdropRegistrationsInfoCsvQuery({
 *   variables: {
 *      blockchain: // value for 'blockchain'
 *      contract: // value for 'contract'
 *   },
 * });
 */
export function useFetchProjectAirdropRegistrationsInfoCsvQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchProjectAirdropRegistrationsInfoCsvDocument, options);
}
export function useFetchProjectAirdropRegistrationsInfoCsvLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchProjectAirdropRegistrationsInfoCsvDocument, options);
}
export function useFetchProjectAirdropRegistrationsInfoCsvSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchProjectAirdropRegistrationsInfoCsvDocument, options);
}
export const FetchProjectLinksClicksInfoCsvDocument = gql `
    query FetchProjectLinksClicksInfoCsv($blockchain: String!, $contract: String!) {
  fetchProjectLinksClicksInfoCsv(blockchain: $blockchain, contract: $contract)
}
    `;
/**
 * __useFetchProjectLinksClicksInfoCsvQuery__
 *
 * To run a query within a React component, call `useFetchProjectLinksClicksInfoCsvQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchProjectLinksClicksInfoCsvQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchProjectLinksClicksInfoCsvQuery({
 *   variables: {
 *      blockchain: // value for 'blockchain'
 *      contract: // value for 'contract'
 *   },
 * });
 */
export function useFetchProjectLinksClicksInfoCsvQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchProjectLinksClicksInfoCsvDocument, options);
}
export function useFetchProjectLinksClicksInfoCsvLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchProjectLinksClicksInfoCsvDocument, options);
}
export function useFetchProjectLinksClicksInfoCsvSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchProjectLinksClicksInfoCsvDocument, options);
}
export const FetchProjectReactionsInfoCsvDocument = gql `
    query FetchProjectReactionsInfoCsv($blockchain: String!, $contract: String!) {
  fetchProjectReactionsInfoCsv(blockchain: $blockchain, contract: $contract)
}
    `;
/**
 * __useFetchProjectReactionsInfoCsvQuery__
 *
 * To run a query within a React component, call `useFetchProjectReactionsInfoCsvQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchProjectReactionsInfoCsvQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchProjectReactionsInfoCsvQuery({
 *   variables: {
 *      blockchain: // value for 'blockchain'
 *      contract: // value for 'contract'
 *   },
 * });
 */
export function useFetchProjectReactionsInfoCsvQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchProjectReactionsInfoCsvDocument, options);
}
export function useFetchProjectReactionsInfoCsvLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchProjectReactionsInfoCsvDocument, options);
}
export function useFetchProjectReactionsInfoCsvSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchProjectReactionsInfoCsvDocument, options);
}
export const FetchProjectsKpiSettingsDocument = gql `
    query FetchProjectsKPISettings {
  fetchProjectsKPISettings {
    id
    value
  }
}
    `;
/**
 * __useFetchProjectsKpiSettingsQuery__
 *
 * To run a query within a React component, call `useFetchProjectsKpiSettingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchProjectsKpiSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchProjectsKpiSettingsQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchProjectsKpiSettingsQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchProjectsKpiSettingsDocument, options);
}
export function useFetchProjectsKpiSettingsLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchProjectsKpiSettingsDocument, options);
}
export function useFetchProjectsKpiSettingsSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchProjectsKpiSettingsDocument, options);
}
export const FetchUnarchivedReferralTypesDocument = gql `
    query FetchUnarchivedReferralTypes {
  fetchUnarchivedReferralTypes {
    id
    name
    description
    archived
    discountPercentage
    color
  }
}
    `;
/**
 * __useFetchUnarchivedReferralTypesQuery__
 *
 * To run a query within a React component, call `useFetchUnarchivedReferralTypesQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchUnarchivedReferralTypesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchUnarchivedReferralTypesQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchUnarchivedReferralTypesQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchUnarchivedReferralTypesDocument, options);
}
export function useFetchUnarchivedReferralTypesLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchUnarchivedReferralTypesDocument, options);
}
export function useFetchUnarchivedReferralTypesSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchUnarchivedReferralTypesDocument, options);
}
export const FetchReferralTypesPageDocument = gql `
    query FetchReferralTypesPage($filter: ReferralTypeFilterInput!, $sort: ReferralTypeSortInput!, $page: AdminPageInput!) {
  fetchReferralTypesPage(filter: $filter, sort: $sort, page: $page) {
    referralTypes {
      id
      name
      description
      discountPercentage
      archived
      color
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchReferralTypesPageQuery__
 *
 * To run a query within a React component, call `useFetchReferralTypesPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchReferralTypesPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchReferralTypesPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchReferralTypesPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchReferralTypesPageDocument, options);
}
export function useFetchReferralTypesPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchReferralTypesPageDocument, options);
}
export function useFetchReferralTypesPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchReferralTypesPageDocument, options);
}
export const FetchRegistrationInvitePageDocument = gql `
    query FetchRegistrationInvitePage($filter: RegistrationInviteFilterInput!, $sort: RegistrationInviteSortInput!, $page: AdminPageInput!) {
  fetchRegistrationInvitePage(filter: $filter, sort: $sort, page: $page) {
    registrationInvites {
      userId
      id
      ludoIdOrAddress
      reason
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchRegistrationInvitePageQuery__
 *
 * To run a query within a React component, call `useFetchRegistrationInvitePageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchRegistrationInvitePageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchRegistrationInvitePageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchRegistrationInvitePageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchRegistrationInvitePageDocument, options);
}
export function useFetchRegistrationInvitePageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchRegistrationInvitePageDocument, options);
}
export function useFetchRegistrationInvitePageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchRegistrationInvitePageDocument, options);
}
export const FetchTiersDocument = gql `
    query FetchTiers {
  fetchTiers {
    id
    name
    description
    fees {
      blockchain
      fee
    }
    archived
  }
}
    `;
/**
 * __useFetchTiersQuery__
 *
 * To run a query within a React component, call `useFetchTiersQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchTiersQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchTiersQuery({
 *   variables: {
 *   },
 * });
 */
export function useFetchTiersQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchTiersDocument, options);
}
export function useFetchTiersLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchTiersDocument, options);
}
export function useFetchTiersSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchTiersDocument, options);
}
export const FetchTiersPageDocument = gql `
    query FetchTiersPage($filter: TiersFilterInput!, $sort: TiersSortInput!, $page: AdminPageInput!) {
  fetchTiersPage(filter: $filter, sort: $sort, page: $page) {
    tiers {
      id
      name
      description
      fees {
        blockchain
        fee
      }
      archived
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchTiersPageQuery__
 *
 * To run a query within a React component, call `useFetchTiersPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchTiersPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchTiersPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchTiersPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchTiersPageDocument, options);
}
export function useFetchTiersPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchTiersPageDocument, options);
}
export function useFetchTiersPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchTiersPageDocument, options);
}
export const FetchUserFeedbackPageDocument = gql `
    query FetchUserFeedbackPage($filter: UserFeedbackFilterInput!, $sort: UserFeedbackSortInput!, $page: AdminPageInput!) {
  fetchUserFeedbackPage(filter: $filter, sort: $sort, page: $page) {
    userFeedbacks {
      userId
      id
      email
      satisfactionScore
      missedFeature
      howEasyToUseScore
      performanceScore
      whatToImprove
      comments
    }
    nextPage {
      elements
      lastNum
      num
      size
      token
    }
  }
}
    `;
/**
 * __useFetchUserFeedbackPageQuery__
 *
 * To run a query within a React component, call `useFetchUserFeedbackPageQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchUserFeedbackPageQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useFetchUserFeedbackPageQuery({
 *   variables: {
 *      filter: // value for 'filter'
 *      sort: // value for 'sort'
 *      page: // value for 'page'
 *   },
 * });
 */
export function useFetchUserFeedbackPageQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useQuery(FetchUserFeedbackPageDocument, options);
}
export function useFetchUserFeedbackPageLazyQuery(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useLazyQuery(FetchUserFeedbackPageDocument, options);
}
export function useFetchUserFeedbackPageSuspenseQuery(baseOptions) {
    const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };
    return Apollo.useSuspenseQuery(FetchUserFeedbackPageDocument, options);
}