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

package/resources/api/loyalty/loyalty.d.ts

@@ -0,0 +1,807 @@
+import { APIResource } from "../../../resource.js";
+import * as Core from "../../../core.js";
+import * as AccountsAPI from "./accounts.js";
+import { AccountGetRankParams, AccountGetRankResponse, AccountListParams, AccountListResponse, Accounts } from "./accounts.js";
+import * as BadgesAPI from "./badges.js";
+import { BadgeCreateParams, BadgeCreateResponse, BadgeDeleteResponse, BadgeListParams, BadgeListResponse, BadgeRevokeParams, BadgeRevokeResponse, BadgeRewardParams, BadgeRewardResponse, BadgeUpdateParams, BadgeUpdateResponse, Badges } from "./badges.js";
+import * as CurrenciesAPI from "./currencies.js";
+import { Currencies, CurrencyCreateParams, CurrencyCreateResponse, CurrencyListParams, CurrencyListResponse } from "./currencies.js";
+import * as MultipliersAPI from "./multipliers.js";
+import { MultiplierCreateParams, MultiplierCreateResponse, MultiplierDeleteByExternalIDParams, MultiplierDeleteByExternalIDResponse, MultiplierDeleteResponse, MultiplierListParams, MultiplierListResponse, MultiplierUpdateParams, MultiplierUpdateResponse, Multipliers } from "./multipliers.js";
+import * as QuestionsAPI from "./questions.js";
+import { QuestionCreateParams, QuestionCreateResponse, QuestionListParams, QuestionListResponse, QuestionUpdateParams, QuestionUpdateResponse, Questions } from "./questions.js";
+import * as QuestionsResponsesAPI from "./questions-responses.js";
+import { QuestionsResponseListParams, QuestionsResponseListResponse, QuestionsResponseSubmitParams, QuestionsResponseSubmitResponse, QuestionsResponses } from "./questions-responses.js";
+import * as RuleEditsAPI from "./rule-edits.js";
+import { RuleEditListParams, RuleEditListResponse, RuleEditRestoreParams, RuleEditRestoreResponse, RuleEdits } from "./rule-edits.js";
+import * as RulesAPI from "./rules.js";
+import { RuleCompleteParams, RuleCompleteResponse, RuleCreateParams, RuleCreateResponse, RuleDeleteResponse, RuleGetStatusParams, RuleGetStatusResponse, RuleListParams, RuleListResponse, RuleUpdateParams, RuleUpdateResponse, Rules } from "./rules.js";
+export declare class Loyalty extends APIResource {
+    accounts: AccountsAPI.Accounts;
+    badges: BadgesAPI.Badges;
+    currencies: CurrenciesAPI.Currencies;
+    multipliers: MultipliersAPI.Multipliers;
+    ruleEdits: RuleEditsAPI.RuleEdits;
+    rules: RulesAPI.Rules;
+    questions: QuestionsAPI.Questions;
+    questionsResponses: QuestionsResponsesAPI.QuestionsResponses;
+    /**
+     * Create a loyalty transaction to update account balances.
+     */
+    createTransaction(body: LoyaltyCreateTransactionParams, options?: Core.RequestOptions): Core.APIPromise<LoyaltyCreateTransactionResponse>;
+    /**
+     * Retrieve configured loyalty rule groups
+     */
+    getRuleGroups(query?: LoyaltyGetRuleGroupsParams, options?: Core.RequestOptions): Core.APIPromise<LoyaltyGetRuleGroupsResponse>;
+    getRuleGroups(options?: Core.RequestOptions): Core.APIPromise<LoyaltyGetRuleGroupsResponse>;
+    /**
+     * Fetch loyalty transaction entries for wallets or users, representing account
+     * balance changes.
+     */
+    listTransactionEntries(query?: LoyaltyListTransactionEntriesParams, options?: Core.RequestOptions): Core.APIPromise<LoyaltyListTransactionEntriesResponse>;
+    listTransactionEntries(options?: Core.RequestOptions): Core.APIPromise<LoyaltyListTransactionEntriesResponse>;
+}
+export interface LoyaltyCreateTransactionResponse {
+    id: string;
+    createdAt: string;
+    description: string;
+    entries: Array<LoyaltyCreateTransactionResponse.Entry>;
+    updatedAt: string;
+}
+export declare namespace LoyaltyCreateTransactionResponse {
+    interface Entry {
+        amount: number;
+        /**
+         * Direction of the transaction entry
+         */
+        direction: 'credit' | 'debit';
+        walletAddress: string;
+        idempotencyKey?: string;
+    }
+}
+export interface LoyaltyGetRuleGroupsResponse {
+    data: Array<LoyaltyGetRuleGroupsResponse.Data>;
+    hasNextPage: boolean;
+}
+export declare namespace LoyaltyGetRuleGroupsResponse {
+    interface Data {
+        id: string;
+        isCollapsible: boolean;
+        isRequired: boolean;
+        loyaltyGroupItems: Array<Data.LoyaltyGroupItem>;
+        name: string;
+        sortId: number;
+        subTitle: string | null;
+    }
+    namespace Data {
+        interface LoyaltyGroupItem {
+            id: string;
+            loyaltyRule: LoyaltyGroupItem.LoyaltyRule;
+            sortId: number;
+        }
+        namespace LoyaltyGroupItem {
+            interface LoyaltyRule {
+                id: string;
+                amount: number | null;
+                deletedAt: string | null;
+                description: string | null;
+                endTime: string | null;
+                frequency: 'none' | 'once' | 'daily' | 'weekly' | 'monthly' | 'immediately' | null;
+                hideInUi: boolean;
+                isRequired: boolean;
+                loyaltyCurrencyId: string;
+                metadata: LoyaltyRule.Metadata;
+                name: string;
+                rewardType: 'points' | 'multiplier';
+                startTime: string | null;
+                type: 'Bonus' | 'BoughtOn' | 'BoughtWithRoyalties' | 'DiscordMessages' | 'Listing' | 'Lodging' | 'MintOn' | 'PoapClaim' | 'SnagSocialsConnected' | 'SnapshotFullset' | 'SnapshotHold' | 'SoldOn' | 'SoldWithRoyalties' | 'TokenHold' | 'TwitterBio' | 'TwitterHashTagPost' | 'Retweet' | 'check_in' | 'code_entry' | 'connect_wallet' | 'connected_discord' | 'connected_email' | 'connected_epic' | 'connected_steam' | 'connected_telegram' | 'connected_twitter' | 'create_partner_account' | 'discord_member' | 'drip_x_follow' | 'drip_x_new_tweet' | 'drip_x_text_in_bio' | 'drip_x_text_in_comment' | 'drip_x_text_in_name' | 'drip_x_tweet' | 'external_rule' | 'link_click' | 'manual_upload' | 'profile_completed' | 'referred_user' | 'smart_contract_event' | 'snapshot_governance' | 'telegram_join' | 'telegram_messages' | 'text_input' | 'token_hold_erc20' | 'tweet_liked_by_project' | 'twitter_comment' | 'twitter_follow' | 'twitter_followers' | 'twitter_like' | 'twitter_post_hashtag' | 'quiz' | 'poll';
+            }
+            namespace LoyaltyRule {
+                interface Metadata {
+                    /**
+                     * Text displayed on the action button.
+                     */
+                    buttonText?: string | null;
+                    /**
+                     * Flag indicating if commenting is required.
+                     */
+                    checkComment?: boolean | null;
+                    /**
+                     * Flag indicating if liking the post is required.
+                     */
+                    checkLike?: boolean | null;
+                    /**
+                     * Flag indicating if reposting is required.
+                     */
+                    checkRepost?: boolean | null;
+                    /**
+                     * Text to check in the Twitter post, username, or bio.
+                     */
+                    checkText?: string | null;
+                    /**
+                     * Array of collections associated with the rule.
+                     */
+                    collection?: Array<Metadata.Collection>;
+                    /**
+                     * Object containing details for the call-to-action.
+                     */
+                    cta?: Metadata.Cta | null;
+                    /**
+                     * API key for custom rewards integration.
+                     */
+                    customRewardsApiKey?: string;
+                    /**
+                     * Array of Discord servers, channels, and roles to join.
+                     */
+                    discordServersToJoin?: Array<Metadata.DiscordServersToJoin> | null;
+                    /**
+                     * Array of drip quests required to complete the rule.
+                     */
+                    dripQuestsToComplete?: Array<Metadata.DripQuestsToComplete> | null;
+                    /**
+                     * Flag indicating whether joining Discord servers is required.
+                     */
+                    enableJoinDiscordServers?: boolean | null;
+                    /**
+                     * Flag indicating whether streaks are enabled.
+                     */
+                    enableStreaks?: boolean | null;
+                    /**
+                     * Flag indicating whether the verified multiplier is enabled.
+                     */
+                    enableVerifiedMultiplier?: boolean;
+                    /**
+                     * Percentage reward given to a user for their first referral.
+                     */
+                    firstReferralReward?: number | null;
+                    /**
+                     * Indicates if the item has never been sold.
+                     */
+                    hasNeverSold?: boolean;
+                    /**
+                     * Indicates if the full royalty has been paid for items.
+                     */
+                    hasPaidFullRoyalty?: boolean;
+                    /**
+                     * Flag indicating if the sale currency is included.
+                     */
+                    hasSaleCurrency?: boolean;
+                    /**
+                     * Indicates if the user has a verified Twitter account.
+                     */
+                    hasVerifiedTwitter?: boolean;
+                    /**
+                     * URL of the image associated with the rule.
+                     */
+                    imageUrl?: string | null;
+                    /**
+                     * Indicates if the multiplier has been applied to rewards.
+                     */
+                    isMultiplierApplied?: boolean;
+                    /**
+                     * Flag indicating if rewards are applied retroactively.
+                     */
+                    isRetroactive?: boolean | null;
+                    /**
+                     * Flag indicating if the token hold multiplier is applied.
+                     */
+                    isTokenHoldMultiplier?: boolean;
+                    /**
+                     * Optional link associated with the metadata.
+                     */
+                    link?: string | null;
+                    /**
+                     * Maximum quantity constraint for token holding.
+                     */
+                    maxQty?: number | null;
+                    /**
+                     * Minimum quantity constraint for token holding.
+                     */
+                    minQty?: number | null;
+                    /**
+                     * Array of loyalty currency IDs used for multipliers.
+                     */
+                    multiplierLoyaltyCurrencyIds?: Array<string> | null;
+                    /**
+                     * Flag indicating whether to include only known users.
+                     */
+                    onlyKnownUsers?: boolean;
+                    /**
+                     * Flag indicating whether to include only native tokens.
+                     */
+                    onlyNative?: boolean;
+                    /**
+                     * Flag indicating whether to include only non-listed items.
+                     */
+                    onlyNonListed?: boolean;
+                    /**
+                     * Indicates if only existing users are rewarded.
+                     */
+                    onlyRewardExistingUser?: boolean;
+                    /**
+                     * give points for only one token ownership per contract
+                     */
+                    onlyRewardSingleTokenOwnership?: boolean | null;
+                    /**
+                     * Promotional code associated with the rule.
+                     */
+                    promoCode?: string;
+                    /**
+                     * Array defining ranges and corresponding rewards.
+                     */
+                    range?: Array<Metadata.Range>;
+                    /**
+                     * Object defining referral requirements.
+                     */
+                    referralRequirements?: Metadata.ReferralRequirements | null;
+                    /**
+                     * Lump sum reward given to a referrer.
+                     */
+                    referrerReward?: number | null;
+                    /**
+                     * Flag indicating if rewards are given per impression.
+                     */
+                    rewardPerImpression?: boolean | null;
+                    /**
+                     * Currency associated with sales.
+                     */
+                    saleCurrency?: string;
+                    /**
+                     * Percentage reward given for a second-level referral.
+                     */
+                    secondReferralReward?: number | null;
+                    /**
+                     * Flag indicating if the multiplier is skipped.
+                     */
+                    skipMultiplier?: boolean | null;
+                    /**
+                     * Object containing details of the associated smart contract.
+                     */
+                    smartContract?: Metadata.SmartContract;
+                    /**
+                     * Array of snapshot proposals for the rule.
+                     */
+                    snapshotProposals?: Array<Metadata.SnapshotProposal> | null;
+                    /**
+                     * Social media platform associated with the rule.
+                     */
+                    socialPlatform?: 'Custom' | 'Discord' | 'EpicGames' | 'Instagram' | 'Steam' | 'Telegram' | 'TikTok' | 'Twitch' | 'X(Twitter)' | 'YouTube' | null;
+                    /**
+                     * URL of the social platform's logo.
+                     */
+                    socialPlatformLogo?: string | null;
+                    /**
+                     * Name of the social platform.
+                     */
+                    socialPlatformName?: string | null;
+                    /**
+                     * Array of streak milestones and corresponding rewards.
+                     */
+                    streakArray?: Array<Metadata.StreakArray> | null;
+                    /**
+                     * ID of the Telegram channel.
+                     */
+                    telegramChannelId?: string | null;
+                    /**
+                     * Time delay in seconds to verify actions.
+                     */
+                    timeDelayToVerifySeconds?: string | number | null;
+                    /**
+                     * Flag indicating if all contracts are tracked.
+                     */
+                    trackAllContracts?: boolean | null;
+                    /**
+                     * URL of the associated Twitter account.
+                     */
+                    twitterAccountUrl?: string;
+                    /**
+                     * Hashtag associated with the Twitter post.
+                     */
+                    twitterHashtag?: string;
+                    /**
+                     * URL of the associated Twitter post.
+                     */
+                    twitterPostUrl?: string;
+                    /**
+                     * Unique identifier of the Twitter user.
+                     */
+                    twitterUserId?: string;
+                    /**
+                     * Twitter username of the user.
+                     */
+                    twitterUsername?: string;
+                    /**
+                     * Minimum length of the verification text.
+                     */
+                    verificationTextMinimumLength?: number | null;
+                    /**
+                     * Multiplier applied to rewards for verified users.
+                     */
+                    verifiedMultiplier?: number | null;
+                    /**
+                     * Placeholder text for verification input fields.
+                     */
+                    verifyPlaceHolderText?: string | null;
+                    /**
+                     * Type of wallet associated with the rule.
+                     */
+                    walletType?: 'evm' | 'solana' | 'imx' | 'sui' | 'ton' | null;
+                }
+                namespace Metadata {
+                    interface Collection {
+                        /**
+                         * Blockchain address of the collection.
+                         */
+                        address?: string;
+                        /**
+                         * Multiplier applied to the rewards for this collection.
+                         */
+                        multiplier?: number;
+                        /**
+                         * Blockchain network of the collection.
+                         */
+                        network?: 'mainnet' | 'polygon' | 'polygon_mumbai' | 'optimism' | 'arbitrum' | 'binance' | 'bscTestnet' | 'avalanche' | 'avalancheFuji' | 'zksync' | 'fantom' | 'fantomTestnet' | 'base' | 'baseSepolia' | 'skaleNebula' | 'xai' | 'berachainArtio' | 'solana' | 'apechain' | 'flowMainnet' | 'campTestnet' | 'sui' | 'vanar' | 'superseed' | 'superseedSepolia' | 'sepolia' | 'optimism_sepolia' | 'arbitrumSepolia' | 'goerli' | 'optimism_goerli' | 'arbitrumGoerli' | 'basecamp' | 'abstract';
+                    }
+                    /**
+                     * Object containing details for the call-to-action.
+                     */
+                    interface Cta {
+                        /**
+                         * Link for the call-to-action.
+                         */
+                        href?: string | null;
+                        /**
+                         * Label for the call-to-action.
+                         */
+                        label?: string | null;
+                    }
+                    interface DiscordServersToJoin {
+                        /**
+                         * ID of the Discord server to join.
+                         */
+                        id?: string;
+                        /**
+                         * Array of Discord channels to join.
+                         */
+                        channels?: Array<DiscordServersToJoin.Channel>;
+                        /**
+                         * Array of roles to assign in the Discord server.
+                         */
+                        roles?: Array<DiscordServersToJoin.Role>;
+                    }
+                    namespace DiscordServersToJoin {
+                        interface Channel {
+                            /**
+                             * ID of the Discord channel.
+                             */
+                            id?: string;
+                            /**
+                             * Array of emojis used in the channel.
+                             */
+                            emojis?: Array<Channel.Emoji>;
+                            /**
+                             * Phrase of text to be present in the discord message
+                             */
+                            text?: string;
+                        }
+                        namespace Channel {
+                            interface Emoji {
+                                /**
+                                 * ID of the emoji used in the channel.
+                                 */
+                                id?: string;
+                            }
+                        }
+                        interface Role {
+                            /**
+                             * ID of the role in the Discord server.
+                             */
+                            id: string;
+                        }
+                    }
+                    interface DripQuestsToComplete {
+                        /**
+                         * ID of the drip quest to complete.
+                         */
+                        id: string;
+                    }
+                    interface Range {
+                        /**
+                         * Reward amount for this range.
+                         */
+                        amount: number;
+                        /**
+                         * End value of the range.
+                         */
+                        endRange: number;
+                        /**
+                         * Start value of the range.
+                         */
+                        startRange: number;
+                    }
+                    /**
+                     * Object defining referral requirements.
+                     */
+                    interface ReferralRequirements {
+                        /**
+                         * Flag indicating if achieving points is required.
+                         */
+                        achievePoints?: boolean | null;
+                        /**
+                         * Flag indicating if completing the profile is required.
+                         */
+                        completeProfile?: boolean | null;
+                        /**
+                         * Flag indicating if connecting Discord is required.
+                         */
+                        connectDiscord?: boolean | null;
+                        /**
+                         * Flag indicating if connecting email is required.
+                         */
+                        connectEmail?: boolean | null;
+                        /**
+                         * Flag indicating if connecting Twitter is required.
+                         */
+                        connectTwitter?: boolean | null;
+                        points?: ReferralRequirements.Points | null;
+                    }
+                    namespace ReferralRequirements {
+                        interface Points {
+                            /**
+                             * Points required for referral.
+                             */
+                            amount?: number | null;
+                            /**
+                             * ID of the loyalty currency for referral.
+                             */
+                            loyaltyCurrecyId?: string | null;
+                        }
+                    }
+                    /**
+                     * Object containing details of the associated smart contract.
+                     */
+                    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.
+                         */
+                        bonus?: Array<SmartContract.Bonus> | null;
+                        /**
+                         * ID of the smart contract.
+                         */
+                        contractId?: string | null;
+                        /**
+                         * Criteria to evaluate the smart contract event.
+                         */
+                        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.
+                         */
+                        withMax?: boolean | null;
+                    }
+                    namespace SmartContract {
+                        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.
+                         */
+                        interface CustomRange {
+                            /**
+                             * End time of the custom range.
+                             */
+                            endsAt?: string | null;
+                            /**
+                             * Start time of the custom range.
+                             */
+                            startsAt?: string | null;
+                        }
+                        interface Param {
+                            /**
+                             * Condition to check for the parameter.
+                             */
+                            condition?: string | null;
+                            /**
+                             * Name of the smart contract parameter.
+                             */
+                            name?: string | null;
+                            /**
+                             * Value of the parameter.
+                             */
+                            value?: string | null;
+                        }
+                    }
+                    interface SnapshotProposal {
+                        /**
+                         * ID of the snapshot proposal.
+                         */
+                        id: string;
+                        /**
+                         * Space associated with the snapshot proposal.
+                         */
+                        space: string;
+                    }
+                    interface StreakArray {
+                        /**
+                         * Reward amount for achieving the streak milestone.
+                         */
+                        streakAmount: number;
+                        /**
+                         * Milestone required to achieve the streak.
+                         */
+                        streakMilestone: number;
+                    }
+                }
+            }
+        }
+    }
+}
+export interface LoyaltyListTransactionEntriesResponse {
+    data: Array<LoyaltyListTransactionEntriesResponse.Data>;
+    hasNextPage: boolean;
+}
+export declare namespace LoyaltyListTransactionEntriesResponse {
+    /**
+     * Schema for a loyalty transaction entry
+     */
+    interface Data {
+        /**
+         * Unique identifier for the transaction entry
+         */
+        id: string;
+        /**
+         * 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>;
+    }
+    namespace Data {
+        /**
+         * Details of the loyalty transaction
+         */
+        interface LoyaltyTransaction {
+            /**
+             * Unique identifier for the loyalty transaction
+             */
+            id: string;
+            /**
+             * Type of the loyalty transaction
+             */
+            type: 'auction_bid' | 'direct_mint' | 'loyalty_rule' | 'api_key' | 'order';
+            /**
+             * Details of the loyalty rule associated with the transaction
+             */
+            loyaltyRule?: LoyaltyTransaction.LoyaltyRule;
+        }
+        namespace LoyaltyTransaction {
+            /**
+             * Details of the loyalty rule associated with the transaction
+             */
+            interface LoyaltyRule {
+                /**
+                 * Unique identifier for the loyalty rule
+                 */
+                id: 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;
+            }
+        }
+    }
+}
+export interface LoyaltyCreateTransactionParams {
+    /**
+     * Description of the loyalty transaction
+     */
+    description: string;
+    /**
+     * Array of transaction entries
+     */
+    entries: Array<LoyaltyCreateTransactionParams.Entry>;
+    /**
+     * Unique identifier for the loyalty currency
+     */
+    loyaltyCurrencyId?: string;
+}
+export declare namespace LoyaltyCreateTransactionParams {
+    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;
+    }
+}
+export interface LoyaltyGetRuleGroupsParams {
+    excludeHidden?: string;
+    limit?: number;
+    organizationId?: string;
+    startingAfter?: string;
+    websiteId?: string;
+}
+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;
+    /**
+     * Direction of the transaction entry to filter by
+     */
+    direction?: 'credit' | 'debit';
+    /**
+     * Key to ensure idempotency of the request
+     */
+    idempotencyKey?: 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;
+}
+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, };
+    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, };
+    export { QuestionsResponses as QuestionsResponses, type QuestionsResponseListResponse as QuestionsResponseListResponse, type QuestionsResponseSubmitResponse as QuestionsResponseSubmitResponse, type QuestionsResponseListParams as QuestionsResponseListParams, type QuestionsResponseSubmitParams as QuestionsResponseSubmitParams, };
+}
+//# sourceMappingURL=loyalty.d.ts.map