QuestSdk

QuestSdk is a javascript development kit which utilizes the quest protocol core apis and provide simple and easy to use methods.

Installation

If this is a brand new project, make sure to create a package.json first with the npm init command.

Installation is done using the npm install command:

$ npm install @questlabs/core

Once the package is installed, you can import the sdk using import or require approach:

Using the import approach for web or mobile projects:

import QuestSdk from "@questlabs/core";

Using the require approach for node.js projects:

const QuestSdk = require("@questlabs/core").default;

Initialization in production environment

// types

interface IConstructor {
    apiKey: string;
    apiSecret: string;
    stagingEnvironment?: boolean;
    userAgent?: UserAgent;
    entityAuthenticationToken?: string;
    entityId?: string;
    platform?: string;
}

export type UserAgent = "MOBILE" | "BROWSER" | "SERVER";

// example usage

const questSdk = new QuestSdk({
    apiKey: "YOUR_API_KEY",
    apiSecret: "YOUR_API_SECRET",
    entityId: "YOUR_ENTITY_ID",
});

Initialization in staging environment

const questSdk = new QuestSdk({
    apiKey: "YOUR_API_KEY",
    apiSecret: "YOUR_API_SECRET",
    entityId: "YOUR_ENTITY_ID",
    stagingEnvironment: true,
});

Base class getters and setters

  QuestSdk.setEntityId({ entityId }: ISetEntity): void

  QuestSdk.getEntityId(): string | undefined

  QuestSdk.setUser({ userId, token }: ISetUser): void

  QuestSdk.getUser(): {
    userId: string | undefined;
    token: string | undefined;
  }

  QuestSdk.setEnvironment({ stagingEnvironment }: ISetEnvironment): void

  QuestSdk.getEnvironment(): {
    stagingEnvironment: boolean;
  }

  QuestSdk.isStagingEnvironment(): boolean

  QuestSdk.setUserAgent({ userAgent }: ISetUserAgent): void

  QuestSdk.getUserAgent(): UserAgent

  QuestSdk.setEntityAuthenticationToken({ token }: ISetEntityAuthenticationToken): void

  QuestSdk.getEntityAuthenticationToken(): string | undefined

  QuestSdk.setApiKeys({ apiKey, apiSecret }: ISetApiKeys): void

  QuestSdk.getApiKeys(): {
    apiKey: string;
    apiSecret: string;
  }

  QuestSdk.getBaseUrl(): string

Core Modules

Entity, User, Badge, DappMetric, DynamicNFT, EntityTag, MembershipTier, Skill, Quest, EntityCreditTier, EntityAuthenticationToken New, EntityDataContract New, EntityFeatureFlag New, EntityPrompt New, GPT New.

Social Modules

Twitter, Discord, Instagram New

Abstract Modules

Xp New, EligibilityCriteria, Reward

Entity

Initialization

import { Entity } from "@questlabs/core/modules/core";
// OR
import { Core } from "@questlabs/core";

const entity = new Entity(questSdk);
// OR
const entity = new Core.Entity(questSdk);

Methods

1. Create new entity

   Used to create a new entity with various details such as name, contracts, description, social media handles, website, and images.

   const { entityId, success, error } = await entity.createNewEntity({
       name: "Acme Corporation",
       contracts: ["0xContract123", "0xContract456"],
       openseaSlug: "acme-corp",
       description: "A leading technology company.",
       chainSource: "ON_CHAIN",
       isPrivate: false,
       decreaseCreditsAt: 50,
       decreaseCreditsFrom: "User567",
       website: "https://www.acmecorp.com",
       imageUrl: "https://www.acmecorp.com/logo.png",
       bannerUrl: "https://www.acmecorp.com/banner.png",
       entityURLAlias: "acme",
       parentEntityId: "ParentEntity789",
       category: "Technology",
   });

2. Add new custom entity ID

   Adds a new custom entity ID by an admin.

   const { success, error } = await entity.addNewCustomEntityId({
       customPlatformName: "Twitter",
       customPlatformId: "123456789",
       entityId: "Entity123",
       name: "John Doe",
       username: "johndoe",
       link: "https://twitter.com/johndoe",
       accessToken: "your-access-token",
       refreshToken: "your-refresh-token",
       expiresIn: "3600",
   });

3. Get all entities

   Returns all entities.

   const { data, success, error } = await entity.getAllEntities({
       page: 1,
       limit: 10,
   });

4. Get entity information

   Used to fetch information about a specific entity based on its ID.

   const { data, success, error } = await entity.getEntityInfo({
       entityId: "entity-123",
   });

5. Get entity ID for alias:

   Retrieves the entity ID for the given alias.

   const { data, success, error } = entity.getEntityIdForAlias({
       alias: "alias-123",
   });

6. Get entity ID for custom ID:

   Retrieves the entity ID for the given custom ID, platform, and record type.

   const { data, success, error } = entity.getEntityIdForCustomId({
       customId: "c-123",
       platform: "twitter",
       recordType: "TWITTER",
   });

7. Update entity

   Used to update an existing entity with new information such as name, description, social media handles, website, and images.

   const { success, error } = await entity.updateEntity({
       entityId: "Entity123",
       name: "Updated Entity Name",
       description: "This is the updated description for the entity.",
       isPrivate: "false",
       decreaseCreditsAt: "50",
       decreaseCreditsFrom: "User567",
       website: "https://updated-entity.com",
       imageUrl: "https://updated-entity.com/image.png",
       bannerUrl: "https://updated-entity.com/banner.png",
       entityURLAlias: "updated-entity",
   });

8. Update Entity theme

   Updates the current theme of an entity.

   const { success, message, error } = await entity.updateEntityTheme({
       theme: {
           backgroundColor: "blue",
           fontFamily: "Hanken Grotesk",
           accentColor: "sky-blue",
       },
       entityId: "e-123",
   });

9. Get Entity theme

   Retrieves the current theme of an entity.

   const { theme, success, error } = await entity.getEntityTheme({
       entityId: "e-123",
   });

10. Update Entity plan

    Updates the current plan of an entity.

    const { success, error } = await entity.updateEntityPlan({
        entityId: "e-123",
        product: {
            name: "FREE",
        },
    });

11. Get users of an entity

    Retrieves the users associated with a specific entity for a given user.

    const { users, success, error } = await entity.getUsersForEntityForUser({
        entityId: "entity-123",
    });

12. Get all admins

    Retrieves all the admins of an entity.

    const { data, message, success, error } = await entity.getAllAdmins({
        entityId: "e-123",
    });

13. Remove admin

    Removes admin of an entity.

    const { message, success, error } = await entity.removeAdmin({
        userId: "u-123",
        entityId: "e-123",
    });

14. Add or update social tokens

    This function adds or updates social tokens for a specified entity using provided authentication and API credentials.

    const { message, success, error } = await entity.addOrUpdateSocialTokens({
        recordType: EntityTokenRecordType.TWITTER,
        entityId: "Entity123",
        authClientId: "your-auth-client-id",
        authClientSecret: "your-auth-client-secret",
        apiKey: "your-api-key",
        apiSecret: "your-api-secret",
        authorizationToken: "your-authorization-token",
        apiHost: "api.twitter.com",
    });

15. Get social tokens

    This async function retrieves the social tokens of a particulay record type for an entity.

    const { data, success, error } = await entity.getSocialTokens({
        recordType: "TWITTER",
        entityId: "e-1234",
    });

16. Approve entity creation

    Approves the creation of an entity with the specified entity data. Only admins can perform this action.

    const { success, error } = await entity.approveEntityCreation({
        entityId: "entity-123",
        baseName: "Mybase",
        baseSymbol: "MEN",
    });

17. Get all pending entities

    Retrieves all pending entities that are yet to be created. Only admins can perform this action.

    const { data, success, error } = await entity.getAllPendingEntities();

18. Add admin

    Adds admin for an entity.

    const { message, success, error } = await entity.addAdminToEntity({
        email: "[email protected]",
        role: "ADMIN",
        name: "Jonny",
        entityId: "e-1212",
    });

19. Get api keys

    Get or generate new api and secret keys for an entity.

    const { data, success, error } = await entity.getOrGenerateNewAPIKey({
        entityId: "e-123",
    });

20. Manually add users to entity

    Adds users to an entity.

    const { success, error } = await entity.manuallyAddUsersToEntity({
        entityId: "entity-123",
        userIds: ["user-456", "user-789"],
    });

21. Get users of an entity

    Get users of an entity

    const { users, success, error } = await entity.getUsersOfEntity({ entityId: "e-1212" });

22. Delete Entity

    Allows to delete an entity, can only be performed by the owner.

    const response = await entity.deleteEntity({
        userId: "u-123",
        token: "login-token",
        entityId: "e-123",
    });

User

Here are the methods of User module and their use cases:

1. Login with wallet

   Logs in the user or creates one if it doesn't exist using wallet information.

   const { userId, token, newUser, success, error } = await user.loginWithWallet({
       entityId: "entity-123",
       walletAddress: "0x1234567890abcdef",
       signature: "0xabcdef1234567890",
       token: "Super secret message",
   });

2. Login with Google

   Logs in the user or creates one if it doesn't exist using Google authentication.

   const { userId, token, newUser, success, error } = await user.loginWithGoogle({
       code: "google-auth-code",
       redirectUri: "https://example.com/callback",
       entityId: "entity-123",
   });

3. Get user details for a given user ID:

   Retrieves user details for a given user ID.

   const { data, isAdmin, success, error } = await user.getUserDetailsForUserId({
       forUserId: "user-123",
   });

4. Set user information

   updates user information for a given user ID.

   const { success, error } = await user.setUserInfo({
       name: "John Doe",
       imageUrl: "https://example.com/johndoe.jpg",
       bannerUrl: "https://example.com/johndoe-banner.jpg",
       location: "New York City, NY",
       expertise: "Web Development",
       goals: ["Become a Full Stack Developer", "Learn Machine Learning"],
       interests: ["Programming", "Gaming", "Travel"],
       about: "I'm a passionate web developer with a love for coding and technology.",
       currentWork: "Software Engineer at XYZ Inc.",
       funFacts: ["I can solve a Rubik's Cube in under a minute!", "I've visited 10 countries so far."],
       role: "Software Engineer",
       sector: "Technology",
   });

5. Create new custom user.

   Creates a new custom user with custom user information.

   const { userId, newUser, success, error } = await user.createNewCustomUser({
       customUserId: "custom-123",
       customPlatform: "MyCustomPlatform",
       entityId: "entity-123",
   });

6. Get user details for a given email

   Retrieves user details for a given email address.

   const { data, isAdmin, success, error } = await user.getUserDetailsForEmail({
       email: "[email protected]",
   });

7. Get user details for a given wallet address

   Retrieves user details for a given wallet address.

   const { data, isAdmin, success, error } = await user.getUserDetailsForWalletAddress({
       walletAddress: "0x1234567890abcdef",
   });

8. Get user's connected socials:

   Retrieves social connections for a given user.

   const { data, success, error } = await user.getConnectedUserSocials({
       entityId: "entity-123",
   });

9. Get entities for a user

   Retrieves entities associated with a given user.

   const { success, error, data, loginAgain, userTokenExpired } = await user.entitesForUser({
       page: 1,
       limit: 10,
   });

10. Get admin entities for a user

    Retrieves admin entities associated with a given user.

    const { data, success, errror } = await user.getAdminEntitiesForUser();

11. Set selected admin entity

    Updates current admin entity.

    const { success, error } = await user.setSelectedAdminEntityId({
        entityId: "entity-123",
    });

12. Send OTP email

    Sends an OTP to a given email for login to a particular entity

    const { data, success, error } = await user.sendOtpEmail({
        email: "[email protected]",
        entity: "e-12123",
    });

13. Verify OTP email

    Verifies the OTP sent to an email for login to a particular entity

    const { userId, token, newUser , success, error } = await user.verifyOtpEmail({
        email: "[email protected]",
        entity: "e-12123"
        otp: 112435,
        name: "Jon Doe",
    });

14. Connect wallet

    Connects a user's wallet address

    const {} = await user.connectWallet({
        entityId: "e-1212",
        walletAddress: "0x1212331211",
        signature: "12121bax1243",
        token: "secret message",
        userId: "u-121243",
    });

Badge

Here are the methods of Badge module and their use cases:

1. Retrieve all badges for a given user

   Retrieves all badges for a given user.

   const { data, success, error } = await badge.getAllBadgesForUser();

2. Get all badges of an entity

   Retrieves all badges of a specific entity.

   const { data, success, error } = await badge.getAllBadgesForEntity({
       entityId: "entity-123",
   });

3. Get badge information of an entity

   Retrieve the badge information for a specific badge associated with an entity.

   const { success, error, data, loginAgain, userTokenExpired } = await badge.getBadgeInfoForEntity({
       entityId: "entity123",
       badgeId: "badge123",
   });

4. Update badge for a specific entity

   Update badge for a specific entity.

   const { success, error } = await badge.updateBadgesForEntity({
       name: "Achievement Badge",
       imageIPFS: "ipfs://your-badge-image-hash",
       description: "This badge signifies a major achievement.",
       entityId: "Entity123",
       skills: "Programming",
       userIds: "User456",
       endsAt: "2023-12-31",
       xp: 100,
       airdropEnabled: false,
       typeData: "Some type data",
       type: "Achievement",
       totalCount: "1",
       visibility: "Public",
       proofType: "Evidence",
   });

5. Claim a badge for an entity

   Claim a badge for an entity.

   const { success, error, calculatedDynamicNFT, nftMinted, loginAgain, userTokenExpired } = await badge.claimBadgeForEntity({
       entityId: "entity123",
       badgeId: "badge123",
       addToDynamicNFT: true,
   });

6. Add users to a badge

   Add users to a badge.

   const { success, error } = await badge.addUsersToBadge({
       entityId: "entity123",
       badgeId: "badge123",
       userIds: ["user456", "user789"],
   });

7. Get my created badges

   Retrieve the badges created by a specific user

   const createdBadges = await badge.getMyCreatedBadges({
       userId: "user123",
       token: "login-token",
   });

8. Get user created badges

   Get badges created by the user

   const { data, success, error } = await badge.getUserCreatedBadges();

9. Add badge for entity

   Add badge for a specific entity

   const { success, error, badgeId, loginAgain, userTokenExpired } = await badge.addBadgeForEntity({
       name: "Achievement Badge",
       imageIPFS: "ipfs://your-badge-image-hash",
       description: "This badge signifies a major achievement.",
       entityId: "Entity123",
       skills: "Programming",
       userIds: "User456",
       endsAt: "2023-12-31",
       xp: 100,
       airdropEnabled: false,
       typeData: "Some type data",
       type: "Achievement",
       totalCount: "1",
       visibility: "Public",
       proofType: "Evidence",
   });

10. Get number of badges earned

    Get the number of badges a user ha earned for an entity

    const { success, error, data, loginAgain, userTokenExpired } = await badge.getNumberOfBadgesEarned();

11. Get user earned badges

    Get the badges a user has earned for an entity

    const { success, error, data, page, totalCount, totalPages, loginAgain, userTokenExpired } = await badge.getUserEarnedBadgesForEntity();

12. Add users to badge

    Add users to badge

    const { success, error, loginAgain, userTokenExpired } = await badge.addUsersToBadge({
        badgeId: "b-59f3a52d-92ee-4dae-944e-b271d6135b91",
        userIds: ["u-cfd286e2-6bd3-4c8b-a404-ef8b0f5cbc8e"],
    });

DappMetric

Here are the methods of DappMetric module and their use cases:

1. Get all dapp metrics

   Retrieve all Dapp metrics for a specific entity.

   const allDappMetrics = await SDK.meta.dappMetric.getAllDappMetrics({
       entityId: "entity123",
       userId: "user123",
       token: "login-token",
   });

2. Get dapp metric for a user

   Retrieves a specific Dapp metric for a user of an entity.

   const dappMetric = await SDK.meta.dappMetric.getDappMetricForUser({
       entityId: "entity123",
       userId: "user123",
       metricId: "metric123",
       adminId: "admin123",
       token: "login-token",
   });

3. Increment dapp metric for a user

   Increment the value of a specific Dapp metric for a user of an entity.

   const incrementedMetric = await SDK.meta.dappMetric.incrementDappMetricForUser({
       entityId: "entity123",
       userId: "user123",
       metricId: "metric123",
       count: 5,
       adminId: "admin123",
       token: "login-token",
   });

4. Get all dapp metrics of a user

   Retrieve all Dapp metrics for a user of an entity.

   const allUserDappMetrics =
     await SDK.meta.dappMetric.getAllDappMetricsForUser(
       entityId: "entity123",
       userId: "user123",
       adminId: "admin123",
       token: "login-token",
     );

5. Increment multiple dapp metrics for a user

   Increment multiple Dapp metrics for a user of an entity.

   const incrementedMetrics = await SDK.meta.dappMetric.incrementMultipleMetricsForUser({
       entityId: "entity123",
       userId: "user123",
       metrics: [
           { metricId: "metric1", count: 2 },
           { metricId: "metric2", count: 3 },
       ],
       adminId: "admin123",
       token: "login-token",
   });

DynamicNFT

Here are the methods of DynamicNFT module and their use cases:

1. Mint dynamic NFT

   Mint a dynamic NFT for a specific user of an entity

   const { data, success, error } = await dynamicNFT.mintDynamicNFT({
       entityId: "entity123",
       type: "type1",
       forUserId: "forUser123",
   });

2. Add running xp for a user

   Add running XP to the dynamic NFT created for the user of a specific entity

   const { success, error, loginAgain, userTokenExpired } = await dynamicNft.addRunningXP({
       xp: 10000,
       title: "TITLE_FOR_INCREMENTING",
   });

3. Get my dynamic NFTs

   Retrieve the dynamic NFTs owned by a user

   const { data, success, error } = await dynamicNFT.getMyDynamicNFTs();

4. Get my dynamic NFT details for an entity

   Retrieve the dynamic NFT details for a specific entity owned by a user.

   const { data, entity_data, success, error } = await dynamicNFT.getMyDynamicNFTDetailsForEntity({
       entityId: "entity123",
   });

5. Get XP for user

   Get XP for a user of an entity

   const { data, success, error } = await dynamicNft.getXpForUser({ entityId: "e-1212", userId: "u-12121" });

6. Get XP for users

   Get XP for multiple users of an entity

   const { data, success, error } = await dynamicNft.getXpForUsers({
       entityId: "e-1212",
       userIds: ["u-12121", "u-9090"],
   });

7. Get XP for entity

   Get XP for an entity

   const { data, success, error } = await dynamicNft.getXpForEntity({
       entityId: "e-1212",
   });

8. Get XP for entities

   Get XP for multiple entities

   const { data, success, error } = await dynamicNft.getXpForEntities({
       entityIds: ["e-1212", "e-9090"],
   });

9. Recalculate user's dynamic NFT

   Recalculate the dynamic NFT for a specific entity owned by a user.

   const { data, success, error } = await dynamicNFT.recalculateUsersDynamicNFT({
       entityId: "entity123",
       userId: "user123",
   });

10. Get all themes for an entity

    Retrieve all themes for a specific entity.

    const { data, success, error } = await dynamicNFT.getAllThemesForEntity({
        entityId: "entity123",
    });

11. Add new dynamic theme for an entity

    Add a new dynamic theme for a specific entity.

    const { themeId, success, error } = await dynamicNFT.addNewThemeForEntity({
        membershipTier: 2,
        title: "Gold Membership",
        price: "49.99 USD",
        entityId: "Entity123",
        backgroundImageIPFS: "your-background-image-hash",
        horizontalLogoImageIPFS: "your-horizontal-logo-image-hash",
        squareLogoImageIPFS: "your-square-logo-image-hash",
        backgroundColor: "#F0F0F0",
        accentColor1: "#FFA500",
        accentColor2: "#008000",
        metadataIPFS: "your-metadata-hash",
    });

12. Get theme details for an entity

    Retrieve the details of a specific theme for a given entity.

    const { data, success, error } = await dynamicNFT.getThemeDetailsForEntity({
        entityId: "entity123",
        themeId: "theme123",
    });

13. Update theme for an entity

    Update the details of a specific theme for a given entity.

    const { success, error } = await dynamicNFT.updateThemeForEntity({
        themeId: "t-1212",
        membershipTier: 2,
        title: "Gold Membership",
        price: "49.99 USD",
        entityId: "Entity123",
        backgroundImageIPFS: "your-background-image-hash",
        horizontalLogoImageIPFS: "your-horizontal-logo-image-hash",
        squareLogoImageIPFS: "your-square-logo-image-hash",
        backgroundColor: "#F0F0F0",
        accentColor1: "#FFA500",
        accentColor2: "#008000",
        metadataIPFS: "your-metadata-hash",
    });

14. Delete theme for an entity

    Delete a specific theme for a given entity.

    const { success, error } = await dynamicNFT.deleteThemeForEntity({
        entityId: "entity123",
        themeId: "theme123",
    });

15. Set default theme for an entity

    Set the default theme for a given entity.

    const { success, error } = await dynamicNFT.setDefaultThemeForEntity({
        entityId: "entity123",
        themeId: "theme123",
    });

16. Get user user xp leaderboard rank

    Retrives the user's rank from the xp leaderboard

    const { success, error, data, loginAgain, userTokenExpired } = await dynamicNft.getUserXpLeaderboardRank();

17. Get user user xp leaderboard

    Retrives the xp leaderboard

    const { success, error, data, page ,totalCount, totalPages, loginAgain, userTokenExpired } = await dynamicNft.getUserXpLeaderboard();

18. Get user user xp history

    Retrives the history of xp increments for a user

    const { success, error, data, page, totalCount, totalPages, loginAgain, userTokenExpired } = await dynamicNft.getUserXpHistory();

EntityTag

Here are the methods of EntityTag module and their use cases:

1. Get all tags for an entity

   Retrieve all tags for a specific entity.

   const { data, success, error } = await entityTag.getAllTagsForEntity({
       entityId: "entity123",
   });

2. Add tag for an entity

   Add a tag for a specific entity.

   const { data, success, error } = await entityTag.addTagForEntity({
       entityId: "entity123",
       tagName: "Tag 1",
       description: "This is tag 1",
   });

3. Update tag of an entity

   Update a tag for a specific entity.

   const { data, success, error } = await entityTag.updateTagForEntity({
       tagId: "tag123",
       tagName: "Updated Tag 1",
       description: "This is the updated tag 1",
       entityId: "entity123",
   });

4. Delete tag of an entity

   Delete a tag for a specific entity.

   const { success, error } = await entityTag.deleteTagForEntity({
       entityId: "entity123",
       tagId: "tag123",
   });

5. Get entity tags for a user

   Retrieve tags associated with a specific entity for a given user, on behalf of another user.

   const { data, success, error } = await entityTag.getEntityTagsForUser({
       entityId: "entity123",
       forUserId: "forUser123",
   });

6. Add entity tag for a user

   Add a user to an entity tag.

   const { data, success, error } = await entityTag.addEntityTagForUser({
       entityId: "entity123",
       forUserId: "forUser123",
       tagId: "tag123",
   });

7. Remove entity tag for a user

   Remove a user from an array of users associated with an entity tag.

   const { success, error } = await entityTag.removeEntityTagForUser({
       entityId: "entity123",
       tagId: "tag123",
       forUserId: "forUser123",
   });

MembershipTier

Here are the methods of MembershipTier module and their use cases:

1. Get all membership tiers of entity

   Retrieve all membership tiers of an entity.

   const { data, success, error } = await membershipTier.getAllMembershipTiersOfEntity({
       entityId: "entity123",
       page: 1,
       limit: 10,
   });

2. Get membership tier details for an entity

   Retrieve membership tier details of an entity.

   const { data, success, error } = await membershipTier.getMembershipTierDetailsForEntity({
       entityId: "entity123",
       memberhipTier: 1,
   });

3. Add new membership tier for an entity

   Add a new membership tier for an entity.

   const { success, error } = await membershipTier.addNewMembershipTierForEntity({
       xpThreshold: 5000,
       membershipTier: 2,
       imageIPFS: "your-membership-tier-image-hash",
       description: "Unlock exclusive benefits with our Gold Membership.",
       entityId: "Entity123",
   });

4. Update membership tier for an entity

   Update the xpThreshold requirements of a specific membership tier for an entity.

   const { success, error } = await membershipTier.updateMembershipTierForEntity({
       membershipTier: 2,
       xpThreshold: 1000,
       entityId: "Entity123",
   });

5. Delete membership tier for entity

   Delete a specific membership tier for an entity.

   const { success, error } = await membershipTier.deleteMembershipTierForEntity({
       entityId: "entity123",
       membershipTier: 1,
   });

Skill

Here are the methods of Skill module and their use cases:

1. Get all skills

   Retrieve all skills associated with an entity.

   const { data, success, error } = await skill.getAllSkills({
       entityId: "entity123",
   });

2. Get skill details

   Retrieve the details of a specific skill.

   const { data, success, error } = await skill.getSkillDetails({
       skillId: "skill123",
   });

3. Add new skill

   Add a new skill for an entity.

   const { skillId, success, error } = await skill.addNewSkill({
       name: "New Skill",
       description: "This is a new skill",
       entityId: "entity123",
   });

4. Add multiple new skills

   Add multiple new skills for an entity.

   const { skillIds, success, error } = await skill.addMultipleNewSkills({
       skills: [
           { name: "Skill 1", description: "This is skill 1" },
           { name: "Skill 2", description: "This is skill 2" },
       ],
       entityId: "entity123",
   });

Quest

Here are the methods of Quest module and their use cases:

1. Get all Quests

   Fetches all the quests with optional params for pagination.

   const { data, success, error } = await quest.getAllQuests({
       page: 1,
       limit: 10,
   });

2. Get all quests of an entity

   Fetches all the quests of a specific entity with optional pagination.

   const { data, success, error } = await quest.getAllQuestsForEntity({
       entityId: "e-101",
       page: 1,
       limit: 10,
   });

3. Get quest details.

   Fetches the details of a quest with stats of the user retrieving it, userId is optional.

   const {
       success,
       error,
       data,
       allCriteriasCompleted,
       claimStatus,
       completedCriteriasPercentage,
       eligibilityData,
       rewards,
       session,
       totalCriteriasCompleted,
       referralCode,
       totalClaimed,
       loginAgain,
       userTokenExpired,
   } = await quest.getQuestDetails({
       entityId: "e-010",
       questId: "q-202",
   });

4. Create Quest.

   Creates a quest for users of an entity to complete and get rewards.

   const eligibilityCirterias: ICreateQuestEligibilityCriteria = [];
   
   eligibilityCirterias.push(eligibilityCriteria.createUserInputText({
       title: "ENter your name",
       xp: 10,
       frequency: EligibilityCriteriaFrequencyConst.ONCE,
       effort: EligibilityCriteriaEffortConst.E1,
       importance: EligibilityCriteriaImportanceConst.I1,
   }));
   
   const rewards: ICreateQuestReward = [];
   
   rewards.push(reward.createXp({
       xp: 10,
   }))
   
   const { id, success, error, loginAgain, userTokenExpired } = await quest.createQuest({
       title: "Epic Adventure Quest",
       entityId: "Entity123",
       description: "Embark on a journey filled with challenges and rewards!",
       imageURL: "https://example.com/quest-image.jpg",
       endsAt: new Date("2023-12-31T23:59:59Z"),
       hasReferral: true,
       referralXP: 50,
       theme: {
           background: "#F0F0F0",
           textColor: "#333333"
       },
       isPrivate: false
       eligibilityCirterias: eligibilityCirterias,
       rewards: rewards,
   });

5. Update Quest

   Updates a quest of an entity.

   const { success, error } = await quest.updateQuest({
       entityId: "e-123",
       questId: "q-123",
       title: "Updated quest title",
   });

6. Delete quest

   Deletes a quest.

   const { success, error, message } = await quest.deleteQuest({
       entityId: "e-123",
       questId: "q-123",
   });

7. Verify quest criteria for user

   Verifies a criteria for a user whether they have completed or not.

   const { success, error, loginAgin, status } = await quest.verifyQuestCriteriaForAUser({
       entityId: "e-123",
       questId: "q-123",
       criteriaId: "c-1212",
       answer: ["My name is Jon"],
   });

8. Verify multiple quest criterias for user

   Verifies multiple criteria for a user whether they have completed or not.

   const { success, error, loginAgin, status } = await quest.verifyMultipleQuestCriteriaForAUser({
       entityId: "e-123",
       questId: "q-123",
       criterias: [
           {
               criteriaId: "c-1212",
               answer: ["My name is Jon"],
           },
           {
               criteriaId: "c-090",
               answer: [20],
           },
       ],
   });

9. Claim quest rewards

   Allows user to claim the rewards of a quest if they have completed all the eligibility criterias.

   const { success, error } = await quest.claimQuestRewards({
       questId: "q-123",
       entityId: "e-123",
   });

10. Get Quest Summary

    Get quest summary details.

    const { summary, success, error } = await quest.getQuestSummary({
        entityId: "e-123",
        questId: "q-123",
    });

11. Get referral code of user for quest.

    Get referral code for the user for a particular quest, which can be used to share with others.

    const { referralCode, success, error } = await quest.getOrSetNewReferralCodeForQuestAndUser({
        entityId: "e-123",
        questId: "q-123",
    });

12. Get referral leaderboard.

    Get leaderboard for all the referrals.

    const { data, success, error } = await quest.getReferralLeaderboard({
        entityId: "e-123",
        questId: "q-123",
    });

13. Get quest submissions

    Get quest user submission details with referrals

    const { data, success, error } = await quest.getQuestSubmissions({ questId: "q-121", entityId: "e-1212" });

14. Create metric quest

    Create metric quest which doesn't have any criterias other than metric

    const { success, error, questId, loginAgain, userTokenExpired } = await quest.createMetricQuest({
            metric: {
                metricId: "daily_login",
                metricType: "threshold",
                threshold: 30
            },
            autoClaimRewards: true,
            repeatRewardsBasedOnMetricCount: false,
            title: "30 days login",
            rewards: [
                {
                    type: "REWARD_XP",
                    xp: 10,
                }
            ],
            description: "Login for 30 days",
        });

15. Get metric quest details

    Get metric quest details

    const { success, error, data, loginAgain, userTokenExpired } = await quest.getMetricQuestDetails({
        questId: "q-893aa9ae-d479-4e89-80f0-7a99a8c50b96",
        entityId: "e-9946bedf-3c65-4111-b296-ca6fd2a3a738"
    });

EntityCreditTier

Here are the methods of EntityCreditTier module and their use cases:

1. Add Credit Tier for Entity

   Add a new credit tier for an entity.

   const { data, success, error } = await entityCreditTier.addCreditTierForEntity({
       creditsTierId: "tier123",
       creditsTierName: "New Tier",
       price: 10,
       creditsAmount: 100,
       extraCreditsAmount: 50,
       recurringTimePeriod: "MONTHLY",
       entityId: "entity123",
   });

2. Update Credit Tier for Entity

   Update an existing credit tier for an entity.

   const { data, success, error } = await entityCreditTier.updateCreditTierForEntity({
       creditsTierId: "tier123",
       price: 15,
       entityId: "entity123",
   });

3. Get credit tiers for entity

   Fetches the credit tiers info of an entity.

   const { data, success, error } = await entityCreditTier.getCreditTiersForEntity({
       entityId: "entity123",
   });

4. Get credit info for a user

   Fetches the credit info for a user of an entity.

   const { data, success, error } = await entityCreditTier.getCreditInfoForUser({
       entityId: "entity123",
       forUserId: "user123",
   });

5. Buy credit for entity

   Purchase credits for an entity.

   const { success, error } = await entityCreditTier.buyCreditsForEntity({
       creditsTierId: "tier123",
       intentId: "intent123",
       entityId: "entity123",
   });

6. Buy Credits for User

   Purchase credits for a user.

   const { success, error } = await entityCreditTier.buyCreditsForUser({
       creditsTierId: "tier123",
       intentId: "intent123",
       entityId: "entity123",
       forUserId: "user123",
   });

7. Decrement credits for a user

   Decrements credits of a user.

   const { success, error } = await entityCreditTier.decrementCreditsForUser({
       creditsAmount: 50,
       entityId: "entity123",
       forUserId: "user123",
   });

8. Decrement credits for a Entity

   Decrements credits of a Entity.

   const { success, error } = await entityCreditTier.decrementCreditsForEntity({
       creditsAmount: 50,
       entityId: "entity123",
   });

9. Create Payment Intent for Entity

   Create a payment intent for an entity.

   const { data, success, error } = await entityCreditTier.createPaymentIntentForEntity({
       entityId: "entity123",
       cardData: {
           email: "[email protected]",
           name: "John Doe",
           address: {
               country: "US",
               postal_code: 12345,
               city: "New York",
               state: "NY",
               line1: "123 Main St",
               line2: "Apt 4B",
           },
       },
       intentData: {
           paymentMethodId: "paymentMethod123",
           amount: 100,
           currency: "USD",
       },
   });

10. Approve payment for entity

    Approves a stripe payment using intentId created by createPaymentIntentForEntity

    const { sucess, error } = await entityCreditTier.approvePaymentForEntity({
        entityId: "e-121",
        intentId: "e-121iklj",
    });

EntityAuthenticationToken

Here are the methods of EntityAuthenticationToken module and their use cases:

1. Create Token

   Create a new authentication token for a user associated with an entity.

   const { data, success, error } = await entityAuthenticationToken.createToken({
       entityId: "entity123",
   });

2. Update Token

   Update the authentication token for a user associated with an entity.

   const { data, success, error } = await entityAuthenticationToken.updateToken({
       entityId: "entity123",
       expiry: "2023-12-31T23:59:59Z",
   });

3. Refresh Token

   Refresh the authentication token for a user associated with an entity.

   const { data, success, error } = await entityAuthenticationToken.refreshToken({
       entityId: "entity123",
       authenticationToken: "your_existing_token_here",
   });

4. Delete Token

   Delete the authentication token for a user associated with an entity.

   const { data, success, error } = await entityAuthenticationToken.deleteToken({
       entityId: "entity123",
   });

5. Get Token

   Get the authentication token for a user associated with an entity.

   const { data, success, error } = await entityAuthenticationToken.getToken({
       entityId: "entity123",
       requestOrigin: "https://yourapp.com",
   });

EntityDataContract

Here are the methods of Twitter module and their use cases:

1. Add new data contract for entity

   Add a new data contract for an entity.

   const { datasetId, success, error } = await entityDataContract.addNewDataContractForEntity({
       name: "New Data Contract",
       description: "This is a new data contract",
       entityId: "entity123",
       source: "Source Name",
       fields: [
           {
               name: "Field 1",
               description: "Description for Field 1",
               validationRules: {
                   type: "string",
                   required: true,
                   minLength: 2,
                   maxLength: 50,
               },
           },
       ],
       tags: ["tag1", "tag2"],
   });

2. Get data contract by ID

   Get a data contract by ID for an entity.

   const { data, success, error } = await entityDataContract.getDataContractByIdForAnEntity({
       entityId: "entity123",
       dataContractId: "dataContract123",
   });

3. Get all data contracts for an entity

   Get all data contracts associated with an entity.

   const { data, success, error } = await entityDataContract.getAllDataContractsForAnEntity({
       entityId: "entity123",
   });

4. Update data contract for an entity

   Update a data contract for an entity.

   const { success, error } = await entityDataContract.updateDataContractForEntity({
       entityId: "entity123",
       name: "Updated Data Contract",
       description: "This is an updated data contract",
       source: "Updated Source",
   });

5. Delete data contract for entity

   Delete a data contract for an entity.

   const { success, error } = await entityDataContract.deleteDataContractForEntity({
       entityId: "entity123",
       dataContractId: "dataContract123",
   });

6. Chat with data contract

   Chat with a data contract for an entity.

   const { data, success, error } = await entityDataContract.chatWithDataContractForEntity({
       entityId: "entity123",
       dataContractId: "dataContract123",
       userInput: "User input text",
       isInternal: true,
   });

7. Fetch fields from google sheets

   Fetch fields from a Google Sheets link for a data contract.

   const { datasetId, success, error } = await entityDataContract.fetchFieldsFromGoogleSheets({
       entityId: "entity123",
       googleSheetLink: "https://docs.google.com/spreadsheets/d/your-sheet-id",
   });

8. Auto generate description

   Auto-generate a description for a data contract based on fields.

   const { res, success, error } = await entityDataContract.autoGenerateDescription({
       entityId: "entity123",
       dataContractId: "dataContract123",
       fields: [
           {
               name: "Field 1",
               description: "Description for Field 1",
               validationRules: {
                   type: "string",
                   required: true,
               },
           },
       ],
   });

EntityFeatureFlags

Here are the methods of EntityFeatureFlags module and their use cases:

1. Get all feature flags for an entity

   Retrieve all feature flags associated with an entity.

   const { data, success, error } = await entityFeatureFlag.getAllFeatureFlagsForEntity({
       entityId: "entity123",
   });

2. Add new feature flag for entity

   Add a new feature flag for an entity.

   const { success, error } = await entityFeatureFlag.addNewFeatureFlagForEntity({
       entityId: "entity123",
       flagName: "NewFeatureFlag",
       description: "This is a new feature flag",
       isEnabled: true,
   });

3. Toggle feature flag for entity

   Toggle the status of a feature flag for an entity.

   const { success, error } = await entityFeatureFlag.toggleFeatureFlagForEntity({
       entityId: "entity123",
       flagName: "FeatureFlagName",
   });

4. Terminate feature flag

   Terminate a feature flag for an entity.

   const { success, error } = await entityFeatureFlag.terminateFeatureFlagForEntity({
       entityId: "entity123",
       flagName: "FeatureFlagName",
   });

5. Get all feature flags stream

   Get a stream of all feature flags for an entity.

   const eventSource = entityFeatureFlag.getAllFeatureFlagsStream({
       entityId: "entity123",
   });

EntityPrompt

Here are the methods of EntityPrompt module and their use cases:

1. Add entity prompt

   Add a new entity prompt for a specific use case.

   const { success, error, usecase } = await entityPrompt.addEntityPrompt({
       entityId: "entity123",
       usecase: "Usecase1",
       actualPrompt: "Please provide your name.",
   });

2. Generate prompt response by usecase

   Generate a prompt response for a specific use case.

   const { success, error, data } = await entityPrompt.generatePromptResponseByUsecase({
       entityId: "entity123",
       usecase: "Usecase1",
       message: "John Doe",
   });

3. Update entity prompt

   Update an existing entity prompt for a specific use case.

   const { success, error, usecase } = await entityPrompt.updateEntityPrompt({
       entityId: "entity123",
       usecase: "Usecase1",
       actualPrompt: "Please provide your updated name.",
   });

GPT

Here are the methods of GPT module and their use cases:

1. Create Text Embedding for Entity

   Create text embeddings for an entity.

   const { embedding, success, error } = await gpt.createTextEmbeddingForEntity({
       embeddingText: "This is a sample text for embedding",
       entityId: "entity123",
   });

2. Make Prompt Request with Embedding

   Make a prompt request with text embedding for an entity.

   const { data, success, error } = await gpt.makePromptRequestWithEmbedding({
       input: "Generate a response based on this input.",
       entityId: "entity123",
   });

Twitter

Here are the methods of Twitter module and their use cases:

1. Connect twitter

   Allows a user to connect their twitter account to an entity.

   const response = await SDK.social.twitter.connect({
       twitterRedirectCode: "redirect-code-124",
       redirectUri: "http://localhost:3000/profile/twitter",
       entityId: "e-123",
       userId: "u-124",
       token: "login-token-123",
   });

2. Disconnect twitter

   Disconnects the user's twitter account from an entity.

   const response = await SDK.social.twitter.disconnect("e-123", "u-124", "login-token-123");

Discord

Here are the methods of Discord module and their use cases:

1. Connect discord

   Allows a user to connect their discord account to an entity.

   const response = await SDK.social.discord.connect({
       discordRedirectCode: "redirect-code-124",
       redirectUri: "http://localhost:3000/profile/discord",
       entityId: "e-123",
       userId: "u-124",
       token: "login-token-123",
   });

2. Disconnect discord

   Disconnects the user's discord account from an entity.

   const response = await SDK.social.discord.disconnect("e-123", "u-124", "login-token-123");

3. Fetch my guilds

   Fetches all the guilds/servers the user is a part of.

   const response = await SDK.social.discord.fetchMyGuilds({
       entityId: "e-123",
       userId: "u-124",
       token: "login-token-123",
   });