@snagsolutions/sdk 0.1.0-alpha.23 → 0.1.0-alpha.231

package/src/resources/loyalty/rule-groups.ts

@@ -7,6 +7,16 @@ import * as Core from '../../core';
 export class RuleGroups extends APIResource {
   /**
    * Create a new loyalty rule groups
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.createRuleGroup({
+   *     name: 'name',
+   *     organizationId: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *     websiteId: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   });
+   * ```
    */
   createRuleGroup(
     body: RuleGroupCreateRuleGroupParams,
@@ -17,6 +27,14 @@ export class RuleGroups extends APIResource {
 
   /**
    * Delete loyalty rule group by ID
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.deleteRuleGroup(
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   );
+   * ```
    */
   deleteRuleGroup(id: string, options?: Core.RequestOptions): Core.APIPromise<unknown> {
     return this._client.delete(`/api/loyalty/rule_groups/${id}`, options);
@@ -24,6 +42,12 @@ export class RuleGroups extends APIResource {
 
   /**
    * Retrieve configured loyalty rule groups
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.getRuleGroups();
+   * ```
    */
   getRuleGroups(
     query?: RuleGroupGetRuleGroupsParams,
@@ -42,6 +66,14 @@ export class RuleGroups extends APIResource {
 
   /**
    * Update loyalty rule group by ID
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.updateRuleGroup(
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   );
+   * ```
    */
   updateRuleGroup(
     id: string,
@@ -135,12 +167,14 @@ export namespace RuleGroupGetRuleGroupsResponse {
 
         endTime: string | null;
 
-        frequency: 'none' | 'once' | 'daily' | 'weekly' | 'monthly' | 'immediately' | null;
+        frequency: 'none' | 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'immediately' | null;
 
         hideInUi: boolean;
 
         isRequired: boolean;
 
+        loyaltyBadge: LoyaltyRule.LoyaltyBadge;
+
         loyaltyCurrencyId: string;
 
         mediaUrl: string | null;
@@ -149,7 +183,7 @@ export namespace RuleGroupGetRuleGroupsResponse {
 
         name: string;
 
-        rewardType: 'points' | 'multiplier';
+        rewardType: 'points' | 'multiplier' | 'badge';
 
         startTime: string | null;
 
@@ -177,6 +211,7 @@ export namespace RuleGroupGetRuleGroupsResponse {
           | 'connected_discord'
           | 'connected_email'
           | 'connected_epic'
+          | 'connected_github'
           | 'connected_steam'
           | 'connected_telegram'
           | 'connected_twitter'
@@ -206,11 +241,63 @@ export namespace RuleGroupGetRuleGroupsResponse {
           | 'twitter_like'
           | 'twitter_post_hashtag'
           | 'quiz'
-          | 'poll';
+          | 'poll'
+          | 'steam_wishlist'
+          | 'liquidity_uniswap_v2'
+          | 'liquidity_uniswap_v3'
+          | 'points_airdrop'
+          | 'youtube_subscribers'
+          | 'youtube_comment'
+          | 'shopify_spend'
+          | 'swap'
+          | 'tiktok_post'
+          | 'post_impressions'
+          | 'discord_join'
+          | 'connected_youtube'
+          | 'stratus_function'
+          | 'connected_tiktok'
+          | 'tiktok_follow'
+          | 'github_repo_star'
+          | 'github_repo_fork'
+          | 'github_repo_collaborator'
+          | 'github_merge_PR'
+          | 'discord_role_grant'
+          | 'connected_reddit'
+          | 'reddit_comment'
+          | 'robinhood_token_hold'
+          | 'connected_instagram'
+          | 'instagram_post';
       }
 
       export namespace LoyaltyRule {
+        export interface LoyaltyBadge {
+          id: string;
+
+          description: string | null;
+
+          imageUrl: string | null;
+
+          name: string;
+        }
+
         export interface Metadata {
+          /**
+           * Flag indicating if the rule allows multiple redemptions. Applies to Enter a Code
+           * only.
+           */
+          allowMultipleRedemptions?: boolean;
+
+          /**
+           * Array of loyalty rule IDs that count as check-in when completed. If ["any"] then
+           * any rule completions count as check-in.
+           */
+          autoCheckInRuleIds?: Array<(string & {}) | 'any'> | null;
+
+          /**
+           * Number of tokens per batch.
+           */
+          batchSize?: number | null;
+
           /**
            * Text displayed on the action button.
            */
@@ -234,7 +321,7 @@ export namespace RuleGroupGetRuleGroupsResponse {
           /**
            * Text to check in the Twitter post, username, or bio.
            */
-          checkText?: string | null;
+          checkText?: string | Array<string> | null;
 
           /**
            * Array of collections associated with the rule.
@@ -244,7 +331,12 @@ export namespace RuleGroupGetRuleGroupsResponse {
           /**
            * Conditions for completing the profile.
            */
-          completeProfileConditions?: Record<string, boolean> | null;
+          completeProfileConditions?: { [key: string]: boolean } | null;
+
+          /**
+           * Description of the external rule condition (only for external rules)
+           */
+          conditionDescription?: string;
 
           /**
            * Object containing details for the call-to-action.
@@ -256,6 +348,11 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           customRewardsApiKey?: string;
 
+          /**
+           * Flag indicating if the rule should use direct RPC to get the balance of tokens.
+           */
+          directRpc?: boolean;
+
           /**
            * Array of Discord servers, channels, and roles to join.
            */
@@ -281,6 +378,11 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           enableVerifiedMultiplier?: boolean;
 
+          /**
+           * Type of ERC20 token for the loyalty rule.
+           */
+          erc20Type?: 'erc20' | 'native';
+
           /**
            * Fill source of the order for the token sale
            */
@@ -291,6 +393,16 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           firstReferralReward?: number | null;
 
+          /**
+           * Name of the GitHub branch to check for PR merge.
+           */
+          githubBranchName?: string | null;
+
+          /**
+           * URL of the GitHub repository to check for star.
+           */
+          githubRepoUrl?: string | null;
+
           /**
            * Flag indicating whether the fill source is included.
            */
@@ -301,11 +413,6 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           hasNeverSold?: boolean;
 
-          /**
-           * Flag indicating whether the order source is included.
-           */
-          hasOrderSource?: boolean;
-
           /**
            * Indicates if the full royalty has been paid for items.
            */
@@ -326,11 +433,21 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           imageUrl?: string | null;
 
+          /**
+           * If enabled, the first transaction done on the platform will complete this rule
+           */
+          isCheckInOnEveryTxn?: boolean;
+
           /**
            * Indicates if the multiplier has been applied to rewards.
            */
           isMultiplierApplied?: boolean;
 
+          /**
+           * Flag indicating if the rule is restricted to new users.
+           */
+          isRestrictedToNewUsers?: boolean;
+
           /**
            * Flag indicating if rewards are applied retroactively.
            */
@@ -346,11 +463,21 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           link?: string | null;
 
+          /**
+           * Liquidity pool details.
+           */
+          liquidity?: Metadata.Liquidity;
+
           /**
            * Maximum quantity constraint for token holding.
            */
           maxQty?: number | null;
 
+          /**
+           * Minimum follower count for the rule. Accepts both number and string values.
+           */
+          minimumFollowerCount?: number | null;
+
           /**
            * Minimum quantity constraint for token holding.
            */
@@ -387,20 +514,40 @@ export namespace RuleGroupGetRuleGroupsResponse {
           onlyRewardSingleTokenOwnership?: boolean | null;
 
           /**
-           * Order source of the order for the token sale
+           * Pre-generated text template that will be used to prefill the post content.
            */
-          orderSource?: string;
+          preGeneratedPostText?: string | null;
 
           /**
            * Promotional code associated with the rule.
            */
           promoCode?: string;
 
+          /**
+           * URL of the CSV file containing promo codes.
+           */
+          promoCodeCsvUrl?: string;
+
+          /**
+           * Numbers of the promotional code to be generated.
+           */
+          promoCodeLength?: number | null;
+
+          /**
+           * Type of the promotional code.
+           */
+          promoCodeType?: 'code' | 'csv' | 'generate';
+
           /**
            * Array defining ranges and corresponding rewards.
            */
           range?: Array<Metadata.Range>;
 
+          /**
+           * ID of the Reddit post.
+           */
+          redditPostId?: string | null;
+
           /**
            * Object defining referral requirements.
            */
@@ -411,11 +558,69 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           referrerReward?: number | null;
 
+          /**
+           * Loyalty currency ID of the referrer reward.
+           */
+          referrerRewardLoyaltyCurrencyId?: string | null;
+
+          /**
+           * Flag indicating if the post link is required.
+           */
+          requirePostLink?: boolean | null;
+
+          /**
+           * Flag indicating if media metadata is required.
+           */
+          requirePostMediaLink?: boolean | null;
+
+          /**
+           * Flag indicating if the rule can also reward badges per range.
+           */
+          rewardBadgePerRange?: boolean;
+
+          /**
+           * Flag indicating if the reward is rewarded by batch.
+           */
+          rewardByBatch?: boolean | null;
+
+          /**
+           * Criteria to evaluate the reward.
+           */
+          rewardCriteria?: 'IMPRESSIONS_COUNT' | 'ELIGIBLE_POST' | null;
+
+          /**
+           * Flag indicating if the reward is rewarded per action.
+           */
+          rewardPerAction?: boolean | null;
+
           /**
            * Flag indicating if rewards are given per impression.
            */
           rewardPerImpression?: boolean | null;
 
+          /**
+           * Flag indicating if the rule should reward based on value of traded tokens
+           * instead of count.
+           */
+          rewardPerValue?: boolean;
+
+          /**
+           * Flag indicating if the rule should reward quality posts.
+           */
+          rewardQualityPosts?: boolean;
+
+          robinhoodSymbols?: Array<string> | null;
+
+          /**
+           * Wallet address of the user can only be used if userId is not provided
+           */
+          royaltyAddress?: string;
+
+          /**
+           * Royalty percentage of the item.
+           */
+          royaltyPercentage?: number;
+
           /**
            * Currency associated with sales.
            */
@@ -455,6 +660,9 @@ export namespace RuleGroupGetRuleGroupsResponse {
             | 'Twitch'
             | 'X(Twitter)'
             | 'YouTube'
+            | 'Google'
+            | 'GitHub'
+            | 'Reddit'
             | null;
 
           /**
@@ -467,11 +675,21 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           socialPlatformName?: string | null;
 
+          /**
+           * ID of the Steam app.
+           */
+          steamAppId?: string | null;
+
           /**
            * Array of streak milestones and corresponding rewards.
            */
           streakArray?: Array<Metadata.StreakArray> | null;
 
+          /**
+           * Metadata for swap loyalty rules
+           */
+          swap?: Metadata.Swap;
+
           /**
            * ID of the Telegram channel.
            */
@@ -487,6 +705,12 @@ export namespace RuleGroupGetRuleGroupsResponse {
            */
           trackAllContracts?: boolean | null;
 
+          /**
+           * Flag indicating if the progress is tracked. If enabled, the rule can only be
+           * completed once the progress is 100%.
+           */
+          trackProgress?: boolean | null;
+
           /**
            * URL of the associated Twitter account.
            */
@@ -530,7 +754,28 @@ export namespace RuleGroupGetRuleGroupsResponse {
           /**
            * Type of wallet associated with the rule.
            */
-          walletType?: 'evm' | 'solana' | 'imx' | 'sui' | 'ton' | null;
+          walletType?:
+            | 'evm'
+            | 'solana'
+            | 'imx'
+            | 'sui'
+            | 'ton'
+            | 'cosmos'
+            | 'ultra'
+            | 'agw'
+            | 'flow_cadence'
+            | 'substrate'
+            | null;
+
+          /**
+           * ID of the Youtube channel.
+           */
+          youtubeChannelId?: string | null;
+
+          /**
+           * ID of the Youtube video.
+           */
+          youtubeVideoId?: string | null;
         }
 
         export namespace Metadata {
@@ -557,7 +802,9 @@ export namespace RuleGroupGetRuleGroupsResponse {
               | 'avalancheFuji'
               | 'base'
               | 'baseSepolia'
+              | 'berachain'
               | 'berachainArtio'
+              | 'berachainBepolia'
               | 'binance'
               | 'bscTestnet'
               | 'campTestnet'
@@ -565,25 +812,42 @@ export namespace RuleGroupGetRuleGroupsResponse {
               | 'fantomTestnet'
               | 'flowMainnet'
               | 'mainnet'
+              | 'nexusTestnet'
               | 'optimism'
               | 'polygon'
               | 'polygon_mumbai'
               | 'skaleNebula'
+              | 'skaleEuropa'
+              | 'skaleCalypso'
               | 'solana'
               | 'sophon'
+              | 'sophonTestnet'
               | 'sui'
               | 'superseed'
               | 'superseedSepolia'
               | 'vanar'
               | 'xai'
               | 'zksync'
+              | 'coti'
+              | 'cotiTestnet'
+              | 'morph'
+              | 'morphTestnet'
+              | 'morphHolesky'
+              | 'ultra'
+              | 'ultraTestnet'
+              | 'nitrograph'
               | 'sepolia'
               | 'optimism_sepolia'
               | 'arbitrumSepolia'
               | 'goerli'
               | 'optimism_goerli'
               | 'arbitrumGoerli'
-              | 'basecamp';
+              | 'basecamp'
+              | 'somnia'
+              | 'zkverify'
+              | 'polkadot'
+              | 'kusama'
+              | 'flow_cadence';
           }
 
           /**
@@ -660,6 +924,111 @@ export namespace RuleGroupGetRuleGroupsResponse {
             id: string;
           }
 
+          /**
+           * Liquidity pool details.
+           */
+          export interface Liquidity {
+            /**
+             * Calculation type of the liquidity pool.
+             */
+            calculationType?: 'fixed' | 'custom';
+
+            /**
+             * Custom function to calculate the the reward amount based on the liquidity
+             * provided per day. X is the reward amount, Y is the liquidity provided per day in
+             * USD.
+             */
+            customFunction?: string;
+
+            /**
+             * Liquidity provided per day in USD
+             */
+            liquidityPerDay?: number;
+
+            /**
+             * Blockchain network of the liquidity pool.
+             */
+            network?:
+              | 'abstract'
+              | 'abstractTestnet'
+              | 'apechain'
+              | 'arbitrum'
+              | 'avalanche'
+              | 'avalancheFuji'
+              | 'base'
+              | 'baseSepolia'
+              | 'berachain'
+              | 'berachainArtio'
+              | 'berachainBepolia'
+              | 'binance'
+              | 'bscTestnet'
+              | 'campTestnet'
+              | 'fantom'
+              | 'fantomTestnet'
+              | 'flowMainnet'
+              | 'mainnet'
+              | 'nexusTestnet'
+              | 'optimism'
+              | 'polygon'
+              | 'polygon_mumbai'
+              | 'skaleNebula'
+              | 'skaleEuropa'
+              | 'skaleCalypso'
+              | 'solana'
+              | 'sophon'
+              | 'sophonTestnet'
+              | 'sui'
+              | 'superseed'
+              | 'superseedSepolia'
+              | 'vanar'
+              | 'xai'
+              | 'zksync'
+              | 'coti'
+              | 'cotiTestnet'
+              | 'morph'
+              | 'morphTestnet'
+              | 'morphHolesky'
+              | 'ultra'
+              | 'ultraTestnet'
+              | 'nitrograph'
+              | 'sepolia'
+              | 'optimism_sepolia'
+              | 'arbitrumSepolia'
+              | 'goerli'
+              | 'optimism_goerli'
+              | 'arbitrumGoerli'
+              | 'basecamp'
+              | 'somnia'
+              | 'zkverify'
+              | 'polkadot'
+              | 'kusama'
+              | 'flow_cadence';
+
+            /**
+             * Indicates if only in-range liquidity is rewarded.
+             */
+            onlyRewardInRangeLiquidity?: boolean;
+
+            /**
+             * Array of liquidity pools associated with the rule.
+             */
+            pools?: Array<Liquidity.Pool>;
+
+            /**
+             * Protocol of the liquidity pool.
+             */
+            protocol?: string;
+          }
+
+          export namespace Liquidity {
+            export interface Pool {
+              /**
+               * Unique identifier of the liquidity pool.
+               */
+              id: string;
+            }
+          }
+
           export interface Range {
             /**
              * Reward amount for this range.
@@ -675,6 +1044,16 @@ export namespace RuleGroupGetRuleGroupsResponse {
              * Start value of the range.
              */
             startRange: number;
+
+            /**
+             * ID of the loyalty badge for this range.
+             */
+            loyaltyBadgeId?: string;
+
+            /**
+             * Amount of the loyalty multiplier for this range.
+             */
+            loyaltyMultiplierAmount?: number;
           }
 
           /**
@@ -727,20 +1106,15 @@ export namespace RuleGroupGetRuleGroupsResponse {
            * Object containing details of the associated smart contract.
            */
           export interface SmartContract {
-            /**
-             * ABI of the smart contract.
-             */
-            abi?: string | null;
-
             /**
              * Mapping of addresses for the smart contract.
              */
             addressMapping?: string | null;
 
             /**
-             * Array of bonus details applied to the rule.
+             * Object containing details of the amount multiplier from the event.
              */
-            bonus?: Array<SmartContract.Bonus> | null;
+            amountMultiplier?: SmartContract.AmountMultiplier | null;
 
             /**
              * ID of the smart contract.
@@ -752,68 +1126,31 @@ export namespace RuleGroupGetRuleGroupsResponse {
              */
             criteria?: 'everyEvent' | 'byParameter' | null;
 
-            /**
-             * Time range applied to the rule.
-             */
-            customRange?: SmartContract.CustomRange | null;
-
             /**
              * Event emitted by the smart contract.
              */
             event?: string | null;
 
-            /**
-             * Maximum value allowed for the parameter.
-             */
-            max?: number | null;
-
             /**
              * Array of parameters for the smart contract.
              */
             params?: Array<SmartContract.Param> | null;
 
             /**
-             * Flag indicating if a bonus is applied.
+             * Type of the smart contract interaction.
              */
-            withBonus?: boolean | null;
-
-            /**
-             * Flag indicating if a custom range is applied.
-             */
-            withCustomRange?: boolean | null;
-
-            /**
-             * Flag indicating if a maximum limit is applied.
-             */
-            withMax?: boolean | null;
+            type?: 'function' | 'event' | null;
           }
 
           export namespace SmartContract {
-            export interface Bonus {
-              /**
-               * Amount of the bonus.
-               */
-              amount?: number | null;
-
-              /**
-               * Number of times the bonus is applied.
-               */
-              count?: number | null;
-            }
-
             /**
-             * Time range applied to the rule.
+             * Object containing details of the amount multiplier from the event.
              */
-            export interface CustomRange {
+            export interface AmountMultiplier {
               /**
-               * End time of the custom range.
+               * Mapping of the value for the smart contract.
                */
-              endsAt?: string | null;
-
-              /**
-               * Start time of the custom range.
-               */
-              startsAt?: string | null;
+              valueMapping?: string | null;
             }
 
             export interface Param {
@@ -857,6 +1194,59 @@ export namespace RuleGroupGetRuleGroupsResponse {
              */
             streakMilestone: number;
           }
+
+          /**
+           * Metadata for swap loyalty rules
+           */
+          export interface Swap {
+            from?: Swap.From;
+
+            provider?: 'any' | 'relay' | 'lifi';
+
+            relayReferrerId?: string;
+
+            requireCrossChainSwap?: boolean;
+
+            to?: Swap.To;
+          }
+
+          export namespace Swap {
+            export interface From {
+              chain?: 'any' | number | string;
+
+              mode?: 'any' | 'specific';
+
+              tokens?: Array<From.Token>;
+
+              trackAmount?: boolean;
+            }
+
+            export namespace From {
+              export interface Token {
+                address: string;
+
+                chainId: string;
+              }
+            }
+
+            export interface To {
+              chain?: 'any' | number | string;
+
+              mode?: 'any' | 'specific';
+
+              tokens?: Array<To.Token>;
+
+              trackAmount?: boolean;
+            }
+
+            export namespace To {
+              export interface Token {
+                address: string;
+
+                chainId: string;
+              }
+            }
+          }
         }
       }
     }