@ludo.ninja/api-server-admin/build/schema.js

Visit [Pharos Production](https://pharosproduction.com) – the software development company specializing in high-load Web3 and DeFi projects. We deliver projects on time and within budget!

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 IBoostType;
(function (IBoostType) {
    IBoostType["Ambassador"] = "AMBASSADOR";
    IBoostType["Educator"] = "EDUCATOR";
})(IBoostType || (IBoostType = {}));
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 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["AdminGift"] = "ADMIN_GIFT";
    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 AddSuggestedOpportunityDocument = gql `
    mutation AddSuggestedOpportunity($userId: ID!, $opportunityId: String!) {
  addSuggestedOpportunity(userId: $userId, opportunityId: $opportunityId)
}
    `;
/**
 * __useAddSuggestedOpportunityMutation__
 *
 * To run a mutation, you first call `useAddSuggestedOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddSuggestedOpportunityMutation` 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 [addSuggestedOpportunityMutation, { data, loading, error }] = useAddSuggestedOpportunityMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *      opportunityId: // value for 'opportunityId'
 *   },
 * });
 */
export function useAddSuggestedOpportunityMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(AddSuggestedOpportunityDocument, 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 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 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 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 RemoveSuggestedOpportunityDocument = gql `
    mutation RemoveSuggestedOpportunity($userId: ID!, $opportunityId: String!) {
  removeSuggestedOpportunity(userId: $userId, opportunityId: $opportunityId)
}
    `;
/**
 * __useRemoveSuggestedOpportunityMutation__
 *
 * To run a mutation, you first call `useRemoveSuggestedOpportunityMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveSuggestedOpportunityMutation` 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 [removeSuggestedOpportunityMutation, { data, loading, error }] = useRemoveSuggestedOpportunityMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *      opportunityId: // value for 'opportunityId'
 *   },
 * });
 */
export function useRemoveSuggestedOpportunityMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(RemoveSuggestedOpportunityDocument, 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 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 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 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 UpdateProfileBoostDocument = gql `
    mutation UpdateProfileBoost($userId: ID!, $boostType: BoostType) {
  updateProfileBoost(userId: $userId, boostType: $boostType)
}
    `;
/**
 * __useUpdateProfileBoostMutation__
 *
 * To run a mutation, you first call `useUpdateProfileBoostMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateProfileBoostMutation` 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 [updateProfileBoostMutation, { data, loading, error }] = useUpdateProfileBoostMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *      boostType: // value for 'boostType'
 *   },
 * });
 */
export function useUpdateProfileBoostMutation(baseOptions) {
    const options = { ...defaultOptions, ...baseOptions };
    return Apollo.useMutation(UpdateProfileBoostDocument, 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
    maxUsag