@snagsolutions/sdk 0.1.0-alpha.19 → 0.1.0-alpha.190

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

@@ -5,29 +5,128 @@ import { isRequestOptions } from '../../core';
 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,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<RuleGroupCreateRuleGroupResponse> {
+    return this._client.post('/api/loyalty/rule_groups/create', { body, ...options });
+  }
+
+  /**
+   * 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);
+  }
+
   /**
    * Retrieve configured loyalty rule groups
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.getRuleGroups();
+   * ```
    */
-  get(query?: RuleGroupGetParams, options?: Core.RequestOptions): Core.APIPromise<RuleGroupGetResponse>;
-  get(options?: Core.RequestOptions): Core.APIPromise<RuleGroupGetResponse>;
-  get(
-    query: RuleGroupGetParams | Core.RequestOptions = {},
+  getRuleGroups(
+    query?: RuleGroupGetRuleGroupsParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<RuleGroupGetRuleGroupsResponse>;
+  getRuleGroups(options?: Core.RequestOptions): Core.APIPromise<RuleGroupGetRuleGroupsResponse>;
+  getRuleGroups(
+    query: RuleGroupGetRuleGroupsParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.APIPromise<RuleGroupGetResponse> {
+  ): Core.APIPromise<RuleGroupGetRuleGroupsResponse> {
     if (isRequestOptions(query)) {
-      return this.get({}, query);
+      return this.getRuleGroups({}, query);
     }
     return this._client.get('/api/loyalty/rule_groups', { query, ...options });
   }
+
+  /**
+   * Update loyalty rule group by ID
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.updateRuleGroup(
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   );
+   * ```
+   */
+  updateRuleGroup(
+    id: string,
+    body?: RuleGroupUpdateRuleGroupParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<RuleGroupUpdateRuleGroupResponse>;
+  updateRuleGroup(
+    id: string,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<RuleGroupUpdateRuleGroupResponse>;
+  updateRuleGroup(
+    id: string,
+    body: RuleGroupUpdateRuleGroupParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<RuleGroupUpdateRuleGroupResponse> {
+    if (isRequestOptions(body)) {
+      return this.updateRuleGroup(id, {}, body);
+    }
+    return this._client.post(`/api/loyalty/rule_groups/${id}`, { body, ...options });
+  }
 }
 
-export interface RuleGroupGetResponse {
-  data: Array<RuleGroupGetResponse.Data>;
+export interface RuleGroupCreateRuleGroupResponse {
+  id: string;
+
+  createdAt: string;
+
+  isCollapsible: boolean;
+
+  isRequired: boolean;
+
+  name: string;
+
+  organizationId: string;
+
+  sortId: number;
+
+  subTitle: string | null;
+
+  updatedAt: string;
+
+  websiteId: string;
+}
+
+export type RuleGroupDeleteRuleGroupResponse = unknown;
+
+export interface RuleGroupGetRuleGroupsResponse {
+  data: Array<RuleGroupGetRuleGroupsResponse.Data>;
 
   hasNextPage: boolean;
 }
 
-export namespace RuleGroupGetResponse {
+export namespace RuleGroupGetRuleGroupsResponse {
   /**
    * Schema for a get loyalty rule groups response
    */
@@ -74,6 +173,8 @@ export namespace RuleGroupGetResponse {
 
         isRequired: boolean;
 
+        loyaltyBadge: LoyaltyRule.LoyaltyBadge;
+
         loyaltyCurrencyId: string;
 
         mediaUrl: string | null;
@@ -82,7 +183,7 @@ export namespace RuleGroupGetResponse {
 
         name: string;
 
-        rewardType: 'points' | 'multiplier';
+        rewardType: 'points' | 'multiplier' | 'badge';
 
         startTime: string | null;
 
@@ -139,11 +240,41 @@ export namespace RuleGroupGetResponse {
           | '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';
       }
 
       export namespace LoyaltyRule {
+        export interface LoyaltyBadge {
+          id: string;
+
+          description: string | null;
+
+          imageUrl: string | null;
+
+          name: string;
+        }
+
         export interface Metadata {
+          /**
+           * Number of tokens per batch.
+           */
+          batchSize?: number | null;
+
           /**
            * Text displayed on the action button.
            */
@@ -167,7 +298,7 @@ export namespace RuleGroupGetResponse {
           /**
            * 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.
@@ -177,7 +308,12 @@ export namespace RuleGroupGetResponse {
           /**
            * 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.
@@ -189,6 +325,11 @@ export namespace RuleGroupGetResponse {
            */
           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.
            */
@@ -214,6 +355,11 @@ export namespace RuleGroupGetResponse {
            */
           enableVerifiedMultiplier?: boolean;
 
+          /**
+           * Type of ERC20 token for the loyalty rule.
+           */
+          erc20Type?: 'erc20' | 'native';
+
           /**
            * Fill source of the order for the token sale
            */
@@ -234,11 +380,6 @@ export namespace RuleGroupGetResponse {
            */
           hasNeverSold?: boolean;
 
-          /**
-           * Flag indicating whether the order source is included.
-           */
-          hasOrderSource?: boolean;
-
           /**
            * Indicates if the full royalty has been paid for items.
            */
@@ -259,11 +400,21 @@ export namespace RuleGroupGetResponse {
            */
           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.
            */
@@ -279,6 +430,11 @@ export namespace RuleGroupGetResponse {
            */
           link?: string | null;
 
+          /**
+           * Liquidity pool details.
+           */
+          liquidity?: Metadata.Liquidity;
+
           /**
            * Maximum quantity constraint for token holding.
            */
@@ -320,14 +476,24 @@ export namespace RuleGroupGetResponse {
           onlyRewardSingleTokenOwnership?: boolean | null;
 
           /**
-           * Order source of the order for the token sale
+           * Promotional code associated with the rule.
            */
-          orderSource?: string;
+          promoCode?: string;
 
           /**
-           * Promotional code associated with the rule.
+           * URL of the CSV file containing promo codes.
            */
-          promoCode?: string;
+          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.
@@ -344,11 +510,62 @@ export namespace RuleGroupGetResponse {
            */
           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;
+
+          /**
+           * 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.
            */
@@ -388,6 +605,7 @@ export namespace RuleGroupGetResponse {
             | 'Twitch'
             | 'X(Twitter)'
             | 'YouTube'
+            | 'Google'
             | null;
 
           /**
@@ -400,11 +618,21 @@ export namespace RuleGroupGetResponse {
            */
           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.
            */
@@ -420,6 +648,12 @@ export namespace RuleGroupGetResponse {
            */
           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.
            */
@@ -463,7 +697,28 @@ export namespace RuleGroupGetResponse {
           /**
            * 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 {
@@ -482,13 +737,17 @@ export namespace RuleGroupGetResponse {
              * Blockchain network of the collection.
              */
             network?:
+              | 'abstract'
+              | 'abstractTestnet'
               | 'apechain'
               | 'arbitrum'
               | 'avalanche'
               | 'avalancheFuji'
               | 'base'
               | 'baseSepolia'
+              | 'berachain'
               | 'berachainArtio'
+              | 'berachainBepolia'
               | 'binance'
               | 'bscTestnet'
               | 'campTestnet'
@@ -496,18 +755,30 @@ export namespace RuleGroupGetResponse {
               | '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'
@@ -515,7 +786,10 @@ export namespace RuleGroupGetResponse {
               | 'optimism_goerli'
               | 'arbitrumGoerli'
               | 'basecamp'
-              | 'abstract';
+              | 'somnia'
+              | 'polkadot'
+              | 'kusama'
+              | 'flow_cadence';
           }
 
           /**
@@ -592,6 +866,110 @@ export namespace RuleGroupGetResponse {
             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'
+              | '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.
@@ -607,6 +985,16 @@ export namespace RuleGroupGetResponse {
              * 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;
           }
 
           /**
@@ -659,20 +1047,15 @@ export namespace RuleGroupGetResponse {
            * 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.
@@ -684,68 +1067,31 @@ export namespace RuleGroupGetResponse {
              */
             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.
-             */
-            withBonus?: boolean | null;
-
-            /**
-             * Flag indicating if a custom range is applied.
-             */
-            withCustomRange?: boolean | null;
-
-            /**
-             * Flag indicating if a maximum limit is applied.
+             * Type of the smart contract interaction.
              */
-            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 {
-              /**
-               * End time of the custom range.
-               */
-              endsAt?: string | null;
-
+            export interface AmountMultiplier {
               /**
-               * Start time of the custom range.
+               * Mapping of the value for the smart contract.
                */
-              startsAt?: string | null;
+              valueMapping?: string | null;
             }
 
             export interface Param {
@@ -789,13 +1135,64 @@ export namespace RuleGroupGetResponse {
              */
             streakMilestone: number;
           }
+
+          /**
+           * Metadata for swap loyalty rules
+           */
+          export interface Swap {
+            provider?: 'any' | 'relay' | 'lifi';
+
+            relayReferrerId?: string;
+
+            requireCrossChainSwap?: boolean;
+
+            swappedToChain?: 'any' | number | string;
+
+            swappedToTokens?: Array<Swap.SwappedToToken>;
+
+            tokenMode?: 'any' | 'specific';
+
+            trackTokenAmount?: boolean;
+          }
+
+          export namespace Swap {
+            export interface SwappedToToken {
+              address: string;
+
+              chainId: string;
+            }
+          }
         }
       }
     }
   }
 }
 
-export interface RuleGroupGetParams {
+export interface RuleGroupUpdateRuleGroupResponse {
+  isCollapsible?: boolean;
+
+  name?: string;
+
+  subTitle?: string;
+}
+
+export interface RuleGroupCreateRuleGroupParams {
+  name: string;
+
+  organizationId: string;
+
+  websiteId: string;
+
+  isCollapsible?: boolean;
+
+  isRequired?: boolean;
+
+  sortId?: number;
+
+  subTitle?: string;
+}
+
+export interface RuleGroupGetRuleGroupsParams {
   excludeHidden?: string;
 
   limit?: number;
@@ -807,6 +1204,22 @@ export interface RuleGroupGetParams {
   websiteId?: string;
 }
 
+export interface RuleGroupUpdateRuleGroupParams {
+  isCollapsible?: boolean;
+
+  name?: string | null;
+
+  subtitle?: string | null;
+}
+
 export declare namespace RuleGroups {
-  export { type RuleGroupGetResponse as RuleGroupGetResponse, type RuleGroupGetParams as RuleGroupGetParams };
+  export {
+    type RuleGroupCreateRuleGroupResponse as RuleGroupCreateRuleGroupResponse,
+    type RuleGroupDeleteRuleGroupResponse as RuleGroupDeleteRuleGroupResponse,
+    type RuleGroupGetRuleGroupsResponse as RuleGroupGetRuleGroupsResponse,
+    type RuleGroupUpdateRuleGroupResponse as RuleGroupUpdateRuleGroupResponse,
+    type RuleGroupCreateRuleGroupParams as RuleGroupCreateRuleGroupParams,
+    type RuleGroupGetRuleGroupsParams as RuleGroupGetRuleGroupsParams,
+    type RuleGroupUpdateRuleGroupParams as RuleGroupUpdateRuleGroupParams,
+  };
 }