@snagsolutions/sdk 0.1.0-alpha.15 → 0.1.0-alpha.151

package/src/resources/{api/loyalty/loyalty.ts → loyalty/rule-groups.ts}

@@ -1,128 +1,63 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../../resource';
-import { isRequestOptions } from '../../../core';
-import * as Core from '../../../core';
-import * as AccountsAPI from './accounts';
-import {
-  AccountGetRankParams,
-  AccountGetRankResponse,
-  AccountListParams,
-  AccountListResponse,
-  Accounts,
-} from './accounts';
-import * as BadgesAPI from './badges';
-import {
-  BadgeCreateParams,
-  BadgeCreateResponse,
-  BadgeDeleteResponse,
-  BadgeListParams,
-  BadgeListResponse,
-  BadgeRevokeParams,
-  BadgeRevokeResponse,
-  BadgeRewardParams,
-  BadgeRewardResponse,
-  BadgeUpdateParams,
-  BadgeUpdateResponse,
-  Badges,
-} from './badges';
-import * as CurrenciesAPI from './currencies';
-import {
-  Currencies,
-  CurrencyCreateParams,
-  CurrencyCreateResponse,
-  CurrencyListParams,
-  CurrencyListResponse,
-} from './currencies';
-import * as MultipliersAPI from './multipliers';
-import {
-  MultiplierCreateParams,
-  MultiplierCreateResponse,
-  MultiplierDeleteByExternalIDParams,
-  MultiplierDeleteByExternalIDResponse,
-  MultiplierDeleteResponse,
-  MultiplierListParams,
-  MultiplierListResponse,
-  MultiplierUpdateParams,
-  MultiplierUpdateResponse,
-  Multipliers,
-} from './multipliers';
-import * as QuestionsAPI from './questions';
-import {
-  QuestionCreateParams,
-  QuestionCreateResponse,
-  QuestionListParams,
-  QuestionListResponse,
-  QuestionUpdateParams,
-  QuestionUpdateResponse,
-  Questions,
-} from './questions';
-import * as QuestionsResponsesAPI from './questions-responses';
-import {
-  QuestionsResponseListParams,
-  QuestionsResponseListResponse,
-  QuestionsResponseSubmitParams,
-  QuestionsResponseSubmitResponse,
-  QuestionsResponses,
-} from './questions-responses';
-import * as RuleEditsAPI from './rule-edits';
-import {
-  RuleEditListParams,
-  RuleEditListResponse,
-  RuleEditRestoreParams,
-  RuleEditRestoreResponse,
-  RuleEdits,
-} from './rule-edits';
-import * as RulesAPI from './rules';
-import {
-  RuleCompleteParams,
-  RuleCompleteResponse,
-  RuleCreateParams,
-  RuleCreateResponse,
-  RuleDeleteResponse,
-  RuleGetStatusParams,
-  RuleGetStatusResponse,
-  RuleListParams,
-  RuleListResponse,
-  RuleUpdateParams,
-  RuleUpdateResponse,
-  Rules,
-} from './rules';
-
-export class Loyalty extends APIResource {
-  accounts: AccountsAPI.Accounts = new AccountsAPI.Accounts(this._client);
-  badges: BadgesAPI.Badges = new BadgesAPI.Badges(this._client);
-  currencies: CurrenciesAPI.Currencies = new CurrenciesAPI.Currencies(this._client);
-  multipliers: MultipliersAPI.Multipliers = new MultipliersAPI.Multipliers(this._client);
-  ruleEdits: RuleEditsAPI.RuleEdits = new RuleEditsAPI.RuleEdits(this._client);
-  rules: RulesAPI.Rules = new RulesAPI.Rules(this._client);
-  questions: QuestionsAPI.Questions = new QuestionsAPI.Questions(this._client);
-  questionsResponses: QuestionsResponsesAPI.QuestionsResponses = new QuestionsResponsesAPI.QuestionsResponses(
-    this._client,
-  );
+import { APIResource } from '../../resource';
+import { isRequestOptions } from '../../core';
+import * as Core from '../../core';
 
+export class RuleGroups extends APIResource {
   /**
-   * Create a loyalty transaction to update account balances.
+   * 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',
+   *   });
+   * ```
    */
-  createTransaction(
-    body: LoyaltyCreateTransactionParams,
+  createRuleGroup(
+    body: RuleGroupCreateRuleGroupParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<LoyaltyCreateTransactionResponse> {
-    return this._client.post('/api/loyalty/transactions', { body, ...options });
+  ): 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();
+   * ```
    */
   getRuleGroups(
-    query?: LoyaltyGetRuleGroupsParams,
+    query?: RuleGroupGetRuleGroupsParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<LoyaltyGetRuleGroupsResponse>;
-  getRuleGroups(options?: Core.RequestOptions): Core.APIPromise<LoyaltyGetRuleGroupsResponse>;
+  ): Core.APIPromise<RuleGroupGetRuleGroupsResponse>;
+  getRuleGroups(options?: Core.RequestOptions): Core.APIPromise<RuleGroupGetRuleGroupsResponse>;
   getRuleGroups(
-    query: LoyaltyGetRuleGroupsParams | Core.RequestOptions = {},
+    query: RuleGroupGetRuleGroupsParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.APIPromise<LoyaltyGetRuleGroupsResponse> {
+  ): Core.APIPromise<RuleGroupGetRuleGroupsResponse> {
     if (isRequestOptions(query)) {
       return this.getRuleGroups({}, query);
     }
@@ -130,61 +65,71 @@ export class Loyalty extends APIResource {
   }
 
   /**
-   * Fetch loyalty transaction entries for wallets or users, representing account
-   * balance changes.
+   * Update loyalty rule group by ID
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.ruleGroups.updateRuleGroup(
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   );
+   * ```
    */
-  listTransactionEntries(
-    query?: LoyaltyListTransactionEntriesParams,
+  updateRuleGroup(
+    id: string,
+    body?: RuleGroupUpdateRuleGroupParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<LoyaltyListTransactionEntriesResponse>;
-  listTransactionEntries(
+  ): Core.APIPromise<RuleGroupUpdateRuleGroupResponse>;
+  updateRuleGroup(
+    id: string,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<LoyaltyListTransactionEntriesResponse>;
-  listTransactionEntries(
-    query: LoyaltyListTransactionEntriesParams | Core.RequestOptions = {},
+  ): Core.APIPromise<RuleGroupUpdateRuleGroupResponse>;
+  updateRuleGroup(
+    id: string,
+    body: RuleGroupUpdateRuleGroupParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.APIPromise<LoyaltyListTransactionEntriesResponse> {
-    if (isRequestOptions(query)) {
-      return this.listTransactionEntries({}, query);
+  ): Core.APIPromise<RuleGroupUpdateRuleGroupResponse> {
+    if (isRequestOptions(body)) {
+      return this.updateRuleGroup(id, {}, body);
     }
-    return this._client.get('/api/loyalty/transaction_entries', { query, ...options });
+    return this._client.post(`/api/loyalty/rule_groups/${id}`, { body, ...options });
   }
 }
 
-export interface LoyaltyCreateTransactionResponse {
+export interface RuleGroupCreateRuleGroupResponse {
   id: string;
 
   createdAt: string;
 
-  description: string;
+  isCollapsible: boolean;
 
-  entries: Array<LoyaltyCreateTransactionResponse.Entry>;
+  isRequired: boolean;
 
-  updatedAt: string;
-}
+  name: string;
 
-export namespace LoyaltyCreateTransactionResponse {
-  export interface Entry {
-    amount: number;
+  organizationId: string;
 
-    /**
-     * Direction of the transaction entry
-     */
-    direction: 'credit' | 'debit';
+  sortId: number;
 
-    walletAddress: string;
+  subTitle: string | null;
 
-    idempotencyKey?: string;
-  }
+  updatedAt: string;
+
+  websiteId: string;
 }
 
-export interface LoyaltyGetRuleGroupsResponse {
-  data: Array<LoyaltyGetRuleGroupsResponse.Data>;
+export type RuleGroupDeleteRuleGroupResponse = unknown;
+
+export interface RuleGroupGetRuleGroupsResponse {
+  data: Array<RuleGroupGetRuleGroupsResponse.Data>;
 
   hasNextPage: boolean;
 }
 
-export namespace LoyaltyGetRuleGroupsResponse {
+export namespace RuleGroupGetRuleGroupsResponse {
+  /**
+   * Schema for a get loyalty rule groups response
+   */
   export interface Data {
     id: string;
 
@@ -228,13 +173,17 @@ export namespace LoyaltyGetRuleGroupsResponse {
 
         isRequired: boolean;
 
+        loyaltyBadge: LoyaltyRule.LoyaltyBadge;
+
         loyaltyCurrencyId: string;
 
+        mediaUrl: string | null;
+
         metadata: LoyaltyRule.Metadata;
 
         name: string;
 
-        rewardType: 'points' | 'multiplier';
+        rewardType: 'points' | 'multiplier' | 'badge';
 
         startTime: string | null;
 
@@ -291,11 +240,38 @@ export namespace LoyaltyGetRuleGroupsResponse {
           | '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';
       }
 
       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.
            */
@@ -319,13 +295,23 @@ export namespace LoyaltyGetRuleGroupsResponse {
           /**
            * 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.
            */
           collection?: Array<Metadata.Collection>;
 
+          /**
+           * Conditions for completing the profile.
+           */
+          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.
            */
@@ -336,6 +322,11 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           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.
            */
@@ -361,11 +352,21 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           enableVerifiedMultiplier?: boolean;
 
+          /**
+           * Fill source of the order for the token sale
+           */
+          fillSource?: string;
+
           /**
            * Percentage reward given to a user for their first referral.
            */
           firstReferralReward?: number | null;
 
+          /**
+           * Flag indicating whether the fill source is included.
+           */
+          hasFillSource?: boolean;
+
           /**
            * Indicates if the item has never been sold.
            */
@@ -391,11 +392,21 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           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.
            */
@@ -411,6 +422,11 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           link?: string | null;
 
+          /**
+           * Liquidity pool details.
+           */
+          liquidity?: Metadata.Liquidity;
+
           /**
            * Maximum quantity constraint for token holding.
            */
@@ -456,6 +472,21 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           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.
            */
@@ -471,11 +502,57 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           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;
+
+          /**
+           * 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.
            */
@@ -515,6 +592,7 @@ export namespace LoyaltyGetRuleGroupsResponse {
             | 'Twitch'
             | 'X(Twitter)'
             | 'YouTube'
+            | 'Google'
             | null;
 
           /**
@@ -527,11 +605,21 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           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.
            */
@@ -547,6 +635,12 @@ export namespace LoyaltyGetRuleGroupsResponse {
            */
           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.
            */
@@ -590,7 +684,17 @@ export namespace LoyaltyGetRuleGroupsResponse {
           /**
            * Type of wallet associated with the rule.
            */
-          walletType?: 'evm' | 'solana' | 'imx' | 'sui' | 'ton' | null;
+          walletType?: 'evm' | 'solana' | 'imx' | 'sui' | 'ton' | 'cosmos' | 'ultra' | 'agw' | null;
+
+          /**
+           * ID of the Youtube channel.
+           */
+          youtubeChannelId?: string | null;
+
+          /**
+           * ID of the Youtube video.
+           */
+          youtubeVideoId?: string | null;
         }
 
         export namespace Metadata {
@@ -609,39 +713,53 @@ export namespace LoyaltyGetRuleGroupsResponse {
              * Blockchain network of the collection.
              */
             network?:
-              | 'mainnet'
-              | 'polygon'
-              | 'polygon_mumbai'
-              | 'optimism'
+              | 'abstract'
+              | 'abstractTestnet'
+              | 'apechain'
               | 'arbitrum'
-              | 'binance'
-              | 'bscTestnet'
               | 'avalanche'
               | 'avalancheFuji'
-              | 'zksync'
-              | 'fantom'
-              | 'fantomTestnet'
               | 'base'
               | 'baseSepolia'
-              | 'skaleNebula'
-              | 'xai'
+              | 'berachain'
               | 'berachainArtio'
-              | 'solana'
-              | 'apechain'
-              | 'flowMainnet'
+              | 'berachainBepolia'
+              | 'binance'
+              | 'bscTestnet'
               | 'campTestnet'
+              | 'fantom'
+              | 'fantomTestnet'
+              | 'flowMainnet'
+              | 'mainnet'
+              | 'nexusTestnet'
+              | 'optimism'
+              | 'polygon'
+              | 'polygon_mumbai'
+              | 'skaleNebula'
+              | 'solana'
+              | 'sophon'
+              | 'sophonTestnet'
               | 'sui'
-              | 'vanar'
               | 'superseed'
               | 'superseedSepolia'
+              | 'vanar'
+              | 'xai'
+              | 'zksync'
+              | 'coti'
+              | 'cotiTestnet'
+              | 'morph'
+              | 'morphTestnet'
+              | 'morphHolesky'
+              | 'ultra'
+              | 'ultraTestnet'
+              | 'nitrograph'
               | 'sepolia'
               | 'optimism_sepolia'
               | 'arbitrumSepolia'
               | 'goerli'
               | 'optimism_goerli'
               | 'arbitrumGoerli'
-              | 'basecamp'
-              | 'abstract';
+              | 'basecamp';
           }
 
           /**
@@ -718,6 +836,104 @@ export namespace LoyaltyGetRuleGroupsResponse {
             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'
+              | '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';
+
+            /**
+             * 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.
@@ -733,6 +949,16 @@ export namespace LoyaltyGetRuleGroupsResponse {
              * 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;
           }
 
           /**
@@ -785,20 +1011,15 @@ export namespace LoyaltyGetRuleGroupsResponse {
            * 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.
@@ -810,68 +1031,31 @@ export namespace LoyaltyGetRuleGroupsResponse {
              */
             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.
+             * Type of the smart contract interaction.
              */
-            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 {
@@ -915,383 +1099,91 @@ export namespace LoyaltyGetRuleGroupsResponse {
              */
             streakMilestone: number;
           }
-        }
-      }
-    }
-  }
-}
 
-export interface LoyaltyListTransactionEntriesResponse {
-  data: Array<LoyaltyListTransactionEntriesResponse.Data>;
+          /**
+           * Metadata for swap loyalty rules
+           */
+          export interface Swap {
+            provider?: 'any' | 'relay' | 'lifi';
 
-  hasNextPage: boolean;
-}
+            relayReferrerId?: string;
 
-export namespace LoyaltyListTransactionEntriesResponse {
-  /**
-   * Schema for a loyalty transaction entry
-   */
-  export interface Data {
-    /**
-     * Unique identifier for the transaction entry
-     */
-    id: string;
+            requireCrossChainSwap?: boolean;
 
-    /**
-     * Amount involved in the transaction
-     */
-    amount: number;
-
-    /**
-     * Timestamp when the transaction entry was created
-     */
-    createdAt: string;
-
-    /**
-     * Direction of the transaction entry
-     */
-    direction: 'credit' | 'debit';
-
-    /**
-     * Unique identifier for the loyalty account
-     */
-    loyaltyAccountId: string;
-
-    /**
-     * Details of the loyalty transaction
-     */
-    loyaltyTransaction: Data.LoyaltyTransaction;
-
-    /**
-     * Unique identifier for the organization
-     */
-    organizationId: string;
-
-    /**
-     * Type of the loyalty transaction
-     */
-    type: 'auction_bid' | 'direct_mint' | 'loyalty_rule' | 'api_key' | 'order';
-
-    /**
-     * Timestamp when the transaction entry was last updated
-     */
-    updatedAt: string;
-
-    /**
-     * Unique identifier for the website
-     */
-    websiteId: string;
-
-    /**
-     * Optional metadata for the transaction entry
-     */
-    metadata?: Record<string, unknown>;
-  }
+            swappedToChain?: 'any' | number | string;
 
-  export namespace Data {
-    /**
-     * Details of the loyalty transaction
-     */
-    export interface LoyaltyTransaction {
-      /**
-       * Unique identifier for the loyalty transaction
-       */
-      id: string;
+            swappedToTokens?: Array<Swap.SwappedToToken>;
 
-      /**
-       * Type of the loyalty transaction
-       */
-      type: 'auction_bid' | 'direct_mint' | 'loyalty_rule' | 'api_key' | 'order';
+            tokenMode?: 'any' | 'specific';
 
-      /**
-       * Details of the loyalty rule associated with the transaction
-       */
-      loyaltyRule?: LoyaltyTransaction.LoyaltyRule;
-    }
+            trackTokenAmount?: boolean;
+          }
 
-    export namespace LoyaltyTransaction {
-      /**
-       * Details of the loyalty rule associated with the transaction
-       */
-      export interface LoyaltyRule {
-        /**
-         * Unique identifier for the loyalty rule
-         */
-        id: string;
+          export namespace Swap {
+            export interface SwappedToToken {
+              address: string;
 
-        /**
-         * Type of the loyalty rule
-         */
-        type: string;
-
-        /**
-         * Description of the loyalty rule
-         */
-        description?: string;
-
-        /**
-         * Optional metadata for the loyalty rule
-         */
-        metadata?: Record<string, unknown>;
-
-        /**
-         * Name of the loyalty rule
-         */
-        name?: string;
+              chainId: string;
+            }
+          }
+        }
       }
     }
   }
 }
 
-export interface LoyaltyCreateTransactionParams {
-  /**
-   * Description of the loyalty transaction
-   */
-  description: string;
-
-  /**
-   * Array of transaction entries
-   */
-  entries: Array<LoyaltyCreateTransactionParams.Entry>;
+export interface RuleGroupUpdateRuleGroupResponse {
+  isCollapsible?: boolean;
 
-  /**
-   * Unique identifier for the loyalty currency
-   */
-  loyaltyCurrencyId?: string;
-}
+  name?: string;
 
-export namespace LoyaltyCreateTransactionParams {
-  export interface Entry {
-    /**
-     * Transaction entry amount.
-     */
-    amount: number;
-
-    /**
-     * Direction of the transaction entry for this wallet address
-     */
-    direction?: 'credit' | 'debit';
-
-    /**
-     * Idempotency key for the transaction entry. Creation will fail if already exists
-     * for this wallet address.
-     */
-    idempotencyKey?: string;
-
-    /**
-     * The wallet address of the user
-     */
-    walletAddress?: string;
-  }
+  subTitle?: string;
 }
 
-export interface LoyaltyGetRuleGroupsParams {
-  excludeHidden?: string;
+export interface RuleGroupCreateRuleGroupParams {
+  name: string;
 
-  limit?: number;
+  organizationId: string;
 
-  organizationId?: string;
+  websiteId: string;
 
-  startingAfter?: string;
+  isCollapsible?: boolean;
 
-  websiteId?: string;
-}
+  isRequired?: boolean;
 
-export interface LoyaltyListTransactionEntriesParams {
-  /**
-   * End date to filter by (exclusive, less than)
-   */
-  createdAtEnd?: string;
-
-  /**
-   * Start date to filter by (inclusive, greater than or equal to)
-   */
-  createdAtStart?: string;
+  sortId?: number;
 
-  /**
-   * Direction of the transaction entry to filter by
-   */
-  direction?: 'credit' | 'debit';
+  subTitle?: string;
+}
 
-  /**
-   * Key to ensure idempotency of the request
-   */
-  idempotencyKey?: string;
+export interface RuleGroupGetRuleGroupsParams {
+  excludeHidden?: string;
 
-  /**
-   * Maximum number of records to return (max 1000)
-   */
   limit?: number;
 
-  /**
-   * Unique identifier for the loyalty rule to filter by
-   */
-  loyaltyRuleId?: string;
-
-  /**
-   * Unique identifier for the loyalty transaction to filter by
-   */
-  loyaltyTransactionId?: string;
-
-  /**
-   * Field to order the results by
-   */
-  orderBy?: 'createdAt' | 'updatedAt' | 'loyaltyAccountLockVersion';
-
-  /**
-   * Unique identifier for the organization to filter by
-   */
   organizationId?: string;
 
-  /**
-   * Pagination cursor to start after a specific resource ID
-   */
   startingAfter?: string;
 
-  /**
-   * Type of the loyalty transaction to filter by
-   */
-  type?: 'auction_bid' | 'direct_mint' | 'loyalty_rule' | 'api_key' | 'order';
-
-  /**
-   * When passed in return the list of fulfilled entries for loyalty rules. If a
-   * loyalty rule has a fulfilled entry this means the user cannot currently complete
-   * the rule. Must be passed in with userId or walletAddress.
-   */
-  userCompletedLoyaltyRuleId?: string | Array<string>;
-
-  /**
-   * External identifier for the user group controlled by you
-   */
-  userGroupExternalIdentifier?: string;
-
-  /**
-   * Unique identifier for the user group
-   */
-  userGroupId?: string;
-
-  /**
-   * User ID or array of User IDs to filter by
-   */
-  userId?: string | Array<string>;
-
-  /**
-   * Wallet address or array of wallet addresses to filter by
-   */
-  walletAddress?: string | Array<string>;
-
-  /**
-   * Identifier for the wallet group to filter by
-   */
-  walletGroupIdentifier?: string;
-
-  /**
-   * Unique identifier for the website to filter by
-   */
   websiteId?: string;
 }
 
-Loyalty.Accounts = Accounts;
-Loyalty.Badges = Badges;
-Loyalty.Currencies = Currencies;
-Loyalty.Multipliers = Multipliers;
-Loyalty.RuleEdits = RuleEdits;
-Loyalty.Rules = Rules;
-Loyalty.Questions = Questions;
-Loyalty.QuestionsResponses = QuestionsResponses;
+export interface RuleGroupUpdateRuleGroupParams {
+  isCollapsible?: boolean;
 
-export declare namespace Loyalty {
-  export {
-    type LoyaltyCreateTransactionResponse as LoyaltyCreateTransactionResponse,
-    type LoyaltyGetRuleGroupsResponse as LoyaltyGetRuleGroupsResponse,
-    type LoyaltyListTransactionEntriesResponse as LoyaltyListTransactionEntriesResponse,
-    type LoyaltyCreateTransactionParams as LoyaltyCreateTransactionParams,
-    type LoyaltyGetRuleGroupsParams as LoyaltyGetRuleGroupsParams,
-    type LoyaltyListTransactionEntriesParams as LoyaltyListTransactionEntriesParams,
-  };
+  name?: string | null;
 
-  export {
-    Accounts as Accounts,
-    type AccountListResponse as AccountListResponse,
-    type AccountGetRankResponse as AccountGetRankResponse,
-    type AccountListParams as AccountListParams,
-    type AccountGetRankParams as AccountGetRankParams,
-  };
-
-  export {
-    Badges as Badges,
-    type BadgeCreateResponse as BadgeCreateResponse,
-    type BadgeUpdateResponse as BadgeUpdateResponse,
-    type BadgeListResponse as BadgeListResponse,
-    type BadgeDeleteResponse as BadgeDeleteResponse,
-    type BadgeRevokeResponse as BadgeRevokeResponse,
-    type BadgeRewardResponse as BadgeRewardResponse,
-    type BadgeCreateParams as BadgeCreateParams,
-    type BadgeUpdateParams as BadgeUpdateParams,
-    type BadgeListParams as BadgeListParams,
-    type BadgeRevokeParams as BadgeRevokeParams,
-    type BadgeRewardParams as BadgeRewardParams,
-  };
-
-  export {
-    Currencies as Currencies,
-    type CurrencyCreateResponse as CurrencyCreateResponse,
-    type CurrencyListResponse as CurrencyListResponse,
-    type CurrencyCreateParams as CurrencyCreateParams,
-    type CurrencyListParams as CurrencyListParams,
-  };
-
-  export {
-    Multipliers as Multipliers,
-    type MultiplierCreateResponse as MultiplierCreateResponse,
-    type MultiplierUpdateResponse as MultiplierUpdateResponse,
-    type MultiplierListResponse as MultiplierListResponse,
-    type MultiplierDeleteResponse as MultiplierDeleteResponse,
-    type MultiplierDeleteByExternalIDResponse as MultiplierDeleteByExternalIDResponse,
-    type MultiplierCreateParams as MultiplierCreateParams,
-    type MultiplierUpdateParams as MultiplierUpdateParams,
-    type MultiplierListParams as MultiplierListParams,
-    type MultiplierDeleteByExternalIDParams as MultiplierDeleteByExternalIDParams,
-  };
-
-  export {
-    RuleEdits as RuleEdits,
-    type RuleEditListResponse as RuleEditListResponse,
-    type RuleEditRestoreResponse as RuleEditRestoreResponse,
-    type RuleEditListParams as RuleEditListParams,
-    type RuleEditRestoreParams as RuleEditRestoreParams,
-  };
-
-  export {
-    Rules as Rules,
-    type RuleCreateResponse as RuleCreateResponse,
-    type RuleUpdateResponse as RuleUpdateResponse,
-    type RuleListResponse as RuleListResponse,
-    type RuleDeleteResponse as RuleDeleteResponse,
-    type RuleCompleteResponse as RuleCompleteResponse,
-    type RuleGetStatusResponse as RuleGetStatusResponse,
-    type RuleCreateParams as RuleCreateParams,
-    type RuleUpdateParams as RuleUpdateParams,
-    type RuleListParams as RuleListParams,
-    type RuleCompleteParams as RuleCompleteParams,
-    type RuleGetStatusParams as RuleGetStatusParams,
-  };
-
-  export {
-    Questions as Questions,
-    type QuestionCreateResponse as QuestionCreateResponse,
-    type QuestionUpdateResponse as QuestionUpdateResponse,
-    type QuestionListResponse as QuestionListResponse,
-    type QuestionCreateParams as QuestionCreateParams,
-    type QuestionUpdateParams as QuestionUpdateParams,
-    type QuestionListParams as QuestionListParams,
-  };
+  subtitle?: string | null;
+}
 
+export declare namespace RuleGroups {
   export {
-    QuestionsResponses as QuestionsResponses,
-    type QuestionsResponseListResponse as QuestionsResponseListResponse,
-    type QuestionsResponseSubmitResponse as QuestionsResponseSubmitResponse,
-    type QuestionsResponseListParams as QuestionsResponseListParams,
-    type QuestionsResponseSubmitParams as QuestionsResponseSubmitParams,
+    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,
   };
 }