@snagsolutions/sdk 0.1.0-alpha.26 → 0.1.0-alpha.260

package/src/resources/loyalty/transactions/transactions.ts

@@ -0,0 +1,930 @@
+// 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 PostsAPI from './posts';
+import { PostListParams, PostListResponse, PostRewardParams, PostRewardResponse, Posts } from './posts';
+import * as RuleStatusesAPI from './rule-statuses';
+import {
+  RuleStatusListParams,
+  RuleStatusListResponse,
+  RuleStatusUpdateParams,
+  RuleStatusUpdateResponse,
+  RuleStatuses,
+} from './rule-statuses';
+
+export class Transactions extends APIResource {
+  ruleStatuses: RuleStatusesAPI.RuleStatuses = new RuleStatusesAPI.RuleStatuses(this._client);
+  posts: PostsAPI.Posts = new PostsAPI.Posts(this._client);
+
+  /**
+   * Create a loyalty transaction to update account balances.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.transactions.createTransaction({
+   *     description: 'Purchase of item X',
+   *     entries: [{ amount: 5 }],
+   *   });
+   * ```
+   */
+  createTransaction(
+    body: TransactionCreateTransactionParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionCreateTransactionResponse> {
+    return this._client.post('/api/loyalty/transactions', { body, ...options });
+  }
+
+  /**
+   * Fetch loyalty transaction entries for wallets or users, representing account
+   * balance changes.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.transactions.getTransactionEntries();
+   * ```
+   */
+  getTransactionEntries(
+    query?: TransactionGetTransactionEntriesParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionGetTransactionEntriesResponse>;
+  getTransactionEntries(
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionGetTransactionEntriesResponse>;
+  getTransactionEntries(
+    query: TransactionGetTransactionEntriesParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionGetTransactionEntriesResponse> {
+    if (isRequestOptions(query)) {
+      return this.getTransactionEntries({}, query);
+    }
+    return this._client.get('/api/loyalty/transaction_entries', { query, ...options });
+  }
+
+  /**
+   * This endpoint allows you to fetch users for a specific badge.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.transactions.listBadgeUsers({
+   *     loyaltyBadgeId: '123e4567-e89b-12d3-a456-426614174222',
+   *   });
+   * ```
+   */
+  listBadgeUsers(
+    query: TransactionListBadgeUsersParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionListBadgeUsersResponse> {
+    return this._client.get('/api/loyalty/badge_users', { query, ...options });
+  }
+
+  /**
+   * Retrieve configured loyalty rule chains
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.transactions.listRuleChains({
+   *     organizationId: '123e4567-e89b-12d3-a456-426614174001',
+   *     websiteId: '123e4567-e89b-12d3-a456-426614174002',
+   *   });
+   * ```
+   */
+  listRuleChains(
+    query: TransactionListRuleChainsParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionListRuleChainsResponse> {
+    return this._client.get('/api/loyalty/rule_chains', { query, ...options });
+  }
+
+  /**
+   * Reset Loyalty Currency of a website
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.transactions.resetLoyaltyCurrency({
+   *     loyaltyCurrencyId:
+   *       '123e4567-e89b-12d3-a456-426614174000',
+   *     type: 'loyalty_reset_balances',
+   *   });
+   * ```
+   */
+  resetLoyaltyCurrency(
+    body: TransactionResetLoyaltyCurrencyParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionResetLoyaltyCurrencyResponse> {
+    return this._client.post('/api/loyalty/reset', { body, ...options });
+  }
+}
+
+export interface TransactionCreateTransactionResponse {
+  id: string;
+
+  createdAt: string;
+
+  description: string;
+
+  entries: Array<TransactionCreateTransactionResponse.Entry>;
+
+  updatedAt: string;
+}
+
+export namespace TransactionCreateTransactionResponse {
+  export interface Entry {
+    amount: number;
+
+    /**
+     * Direction of the transaction entry
+     */
+    direction: 'credit' | 'debit';
+
+    walletAddress: string;
+
+    idempotencyKey?: string;
+  }
+}
+
+export interface TransactionGetTransactionEntriesResponse {
+  data: Array<TransactionGetTransactionEntriesResponse.Data>;
+
+  hasNextPage: boolean;
+}
+
+export namespace TransactionGetTransactionEntriesResponse {
+  /**
+   * Schema for a loyalty transaction entry
+   */
+  export 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' | null;
+
+    /**
+     * Timestamp when the transaction entry was last updated
+     */
+    updatedAt: string;
+
+    /**
+     * Unique identifier for the website
+     */
+    websiteId: string;
+
+    /**
+     * Optional metadata for the transaction entry
+     */
+    metadata?: { [key: string]: unknown };
+  }
+
+  export namespace Data {
+    /**
+     * Details of the loyalty transaction
+     */
+    export 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' | null;
+
+      /**
+       * Details of the loyalty rule associated with the transaction
+       */
+      loyaltyRule?: LoyaltyTransaction.LoyaltyRule;
+    }
+
+    export namespace LoyaltyTransaction {
+      /**
+       * Details of the loyalty rule associated with the transaction
+       */
+      export interface LoyaltyRule {
+        /**
+         * Unique identifier for the loyalty rule
+         */
+        id: string;
+
+        /**
+         * Type of the loyalty rule
+         */
+        type: string;
+
+        /**
+         * Description of the loyalty rule
+         */
+        description?: string;
+
+        loyaltyRuleGroupItem?: LoyaltyRule.LoyaltyRuleGroupItem;
+
+        /**
+         * Optional metadata for the loyalty rule
+         */
+        metadata?: { [key: string]: unknown };
+
+        /**
+         * Name of the loyalty rule
+         */
+        name?: string;
+      }
+
+      export namespace LoyaltyRule {
+        export interface LoyaltyRuleGroupItem {
+          loyaltyRuleGroupId: string;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Response returned upon successful fetching of the badge users.
+ */
+export interface TransactionListBadgeUsersResponse {
+  /**
+   * UUID of the user badge (converted to lowercase)
+   */
+  id: string;
+
+  /**
+   * The date and time the user badge was created
+   */
+  createdAt: string;
+
+  /**
+   * The date and time the user badge was deleted
+   */
+  deletedAt: string | null;
+
+  /**
+   * UUID of the badge (converted to lowercase)
+   */
+  loyaltyBadgeId: string;
+
+  /**
+   * UUID of the organization (converted to lowercase)
+   */
+  organizationId: string;
+
+  /**
+   * Array of progress for the badge
+   */
+  progress: Array<unknown>;
+
+  /**
+   * The status of the badge
+   */
+  status: 'active' | 'inactive' | 'revoked';
+
+  /**
+   * The date and time the user badge was updated
+   */
+  updatedAt: string;
+
+  /**
+   * UUID of the user (converted to lowercase)
+   */
+  userId: string;
+
+  /**
+   * UUID of the website (converted to lowercase)
+   */
+  websiteId: string;
+
+  /**
+   * Whether the user has dismissed the badge in the UI
+   */
+  dismissedInUi?: boolean;
+
+  /**
+   * User associated with the user badge
+   */
+  user?: TransactionListBadgeUsersResponse.User | null;
+}
+
+export namespace TransactionListBadgeUsersResponse {
+  /**
+   * User associated with the user badge
+   */
+  export interface User {
+    /**
+     * Wallet address of the user
+     */
+    walletAddress: string;
+  }
+}
+
+export interface TransactionListRuleChainsResponse {
+  data: Array<TransactionListRuleChainsResponse.Data>;
+
+  hasNextPage: boolean;
+}
+
+export namespace TransactionListRuleChainsResponse {
+  export interface Data {
+    /**
+     * Unique identifier for the rule chain
+     */
+    id: string;
+
+    loyaltyConditions: Array<Data.LoyaltyCondition>;
+
+    /**
+     * Unique identifier for the loyalty rule
+     */
+    loyaltyRuleId: string;
+
+    /**
+     * Name of the rule chain
+     */
+    name: string;
+
+    /**
+     * Type of the operator. AND if all conditions must be met, OR if any condition can
+     * be met.
+     */
+    operatorType?: 'AND' | 'OR';
+  }
+
+  export namespace Data {
+    export interface LoyaltyCondition {
+      /**
+       * Unique identifier for the condition
+       */
+      id: string;
+
+      /**
+       * Amount of the condition
+       */
+      amount: number | null;
+
+      association: Array<LoyaltyCondition.Association>;
+
+      /**
+       * URL of the CSV file
+       */
+      csvUrl: string | null;
+
+      /**
+       * Description of the condition
+       */
+      description: string | null;
+
+      /**
+       * Number of times the condition must be met
+       */
+      repeatCount: number | null;
+
+      /**
+       * Number of times the condition must be met
+       */
+      requiredCount: number | null;
+
+      /**
+       * Type of the condition
+       */
+      type: 'rule' | 'rules' | 'points' | 'section' | 'level' | 'api' | 'badge' | 'badges' | 'csv';
+    }
+
+    export namespace LoyaltyCondition {
+      export interface Association {
+        /**
+         * Unique identifier for the association
+         */
+        id: string;
+
+        /**
+         * Unique identifier for the loyalty badge
+         */
+        loyaltyBadgeId: string | null;
+
+        loyaltyCurrency: Association.LoyaltyCurrency | null;
+
+        /**
+         * Unique identifier for the loyalty currency
+         */
+        loyaltyCurrencyId: string | null;
+
+        loyaltyRule: Association.LoyaltyRule | null;
+
+        /**
+         * Unique identifier for the loyalty rule group
+         */
+        loyaltyRuleGroupId: string | null;
+
+        /**
+         * Unique identifier for the loyalty rule
+         */
+        loyaltyRuleId: string | null;
+      }
+
+      export namespace Association {
+        export interface LoyaltyCurrency {
+          /**
+           * Name of the loyalty currency
+           */
+          name: string;
+        }
+
+        export interface LoyaltyRule {
+          /**
+           * Name of the loyalty rule
+           */
+          name: string;
+        }
+      }
+    }
+  }
+}
+
+export interface TransactionResetLoyaltyCurrencyResponse {
+  success: boolean;
+}
+
+export interface TransactionCreateTransactionParams {
+  /**
+   * Description of the loyalty transaction
+   */
+  description: string;
+
+  /**
+   * Array of transaction entries
+   */
+  entries: Array<TransactionCreateTransactionParams.Entry>;
+
+  /**
+   * Unique identifier for the loyalty currency
+   */
+  loyaltyCurrencyId?: string;
+
+  organizationId?: string;
+
+  websiteId?: string;
+}
+
+export namespace TransactionCreateTransactionParams {
+  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;
+
+    /**
+     * Unique identifier for the loyalty currency for the wallet. Can only use
+     * entry-level currency or transaction-level currency.
+     */
+    loyaltyCurrencyId?: string;
+
+    /**
+     * The wallet address of the user
+     */
+    walletAddress?: string;
+  }
+}
+
+export interface TransactionGetTransactionEntriesParams {
+  /**
+   * End date to filter by (exclusive, less than)
+   */
+  createdAtEnd?: string;
+
+  /**
+   * Start date to filter by (inclusive, greater than or equal to)
+   */
+  createdAtStart?: string;
+
+  /**
+   * Key to ensure idempotency of the request
+   */
+  idempotencyKey?: string;
+
+  /**
+   * Maximum number of records to return (max 100)
+   */
+  limit?: number;
+
+  /**
+   * UUID of the loyalty currency IDs to filter by. Use this to exclude deleted
+   * currencies
+   */
+  loyaltyCurrencyId?: string | Array<string>;
+
+  /**
+   * UUID of the rule group (converted to lowercase)
+   */
+  loyaltyRuleGroupId?: string;
+
+  /**
+   * Unique identifier for the loyalty rule to filter by
+   */
+  loyaltyRuleId?: string;
+
+  loyaltyRuleType?:
+    | '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_github'
+    | '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'
+    | 'steam_wishlist'
+    | 'liquidity_uniswap_v2'
+    | 'liquidity_uniswap_v3'
+    | 'points_airdrop'
+    | 'youtube_subscribers'
+    | 'youtube_comment'
+    | 'shopify_spend'
+    | 'swap'
+    | 'tiktok_post'
+    | 'post_impressions'
+    | 'discord_join'
+    | 'connected_youtube'
+    | 'stratus_function'
+    | 'connected_tiktok'
+    | 'tiktok_follow'
+    | 'github_repo_star'
+    | 'github_repo_fork'
+    | 'github_repo_collaborator'
+    | 'github_merge_PR'
+    | 'discord_role_grant'
+    | 'connected_reddit'
+    | 'reddit_comment'
+    | 'robinhood_token_hold'
+    | 'connected_instagram'
+    | 'instagram_post'
+    | 'instagram_follow'
+    | 'connected_phone'
+    | 'dapps_by_gas_spent'
+    | 'dapps_by_active_users'
+    | 'dapps_by_new_users'
+    | 'dapps_by_transaction_count'
+    | Array<
+        | '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_github'
+        | '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'
+        | 'steam_wishlist'
+        | 'liquidity_uniswap_v2'
+        | 'liquidity_uniswap_v3'
+        | 'points_airdrop'
+        | 'youtube_subscribers'
+        | 'youtube_comment'
+        | 'shopify_spend'
+        | 'swap'
+        | 'tiktok_post'
+        | 'post_impressions'
+        | 'discord_join'
+        | 'connected_youtube'
+        | 'stratus_function'
+        | 'connected_tiktok'
+        | 'tiktok_follow'
+        | 'github_repo_star'
+        | 'github_repo_fork'
+        | 'github_repo_collaborator'
+        | 'github_merge_PR'
+        | 'discord_role_grant'
+        | 'connected_reddit'
+        | 'reddit_comment'
+        | 'robinhood_token_hold'
+        | 'connected_instagram'
+        | 'instagram_post'
+        | 'instagram_follow'
+        | 'connected_phone'
+        | 'dapps_by_gas_spent'
+        | 'dapps_by_active_users'
+        | 'dapps_by_new_users'
+        | 'dapps_by_transaction_count'
+      >;
+
+  /**
+   * Unique identifier for the loyalty transaction to filter by
+   */
+  loyaltyTransactionId?: string;
+
+  /**
+   * Unique identifier for the organization to filter by
+   */
+  organizationId?: string;
+
+  /**
+   * Field to sort the results by
+   */
+  sortBy?: 'createdAt' | 'updatedAt' | 'loyaltyAccountLockVersion';
+
+  /**
+   * Direction to sort the results by
+   */
+  sortDir?: 'asc' | 'desc';
+
+  /**
+   * 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 interface TransactionListBadgeUsersParams {
+  /**
+   * UUID of the loyalty badge (converted to lowercase)
+   */
+  loyaltyBadgeId: string;
+
+  /**
+   * Number of badges to fetch
+   */
+  limit?: number;
+
+  /**
+   * UUID of the organization (optional, converted to lowercase)
+   */
+  organizationId?: string;
+
+  /**
+   * UUID of the badge to start after (converted to lowercase)
+   */
+  startingAfter?: string;
+
+  /**
+   * Status of the badge
+   */
+  status?: 'active' | 'inactive' | 'revoked';
+
+  /**
+   * Wallet Address of the user, or array of wallet addresses.
+   */
+  walletAddress?: string;
+
+  /**
+   * UUID of the website (optional, converted to lowercase)
+   */
+  websiteId?: string;
+}
+
+export interface TransactionListRuleChainsParams {
+  /**
+   * Unique identifier for the organization
+   */
+  organizationId: string;
+
+  /**
+   * Unique identifier for the website
+   */
+  websiteId: string;
+
+  /**
+   * Number of rule chains to return
+   */
+  limit?: number;
+
+  /**
+   * Starting after the given rule chain ID
+   */
+  startingAfter?: string;
+}
+
+export interface TransactionResetLoyaltyCurrencyParams {
+  /**
+   * UUID of the loyalty currency to reset
+   */
+  loyaltyCurrencyId: string;
+
+  type:
+    | 'loyalty_reset_balances'
+    | 'loyalty_reset_balances_data_and_rules'
+    | 'loyalty_reset_balances_data_not_rules';
+
+  /**
+   * UUID of the organization (optional, converted to lowercase)
+   */
+  organizationId?: string;
+
+  /**
+   * UUID of the website (optional, converted to lowercase)
+   */
+  websiteId?: string;
+}
+
+Transactions.RuleStatuses = RuleStatuses;
+Transactions.Posts = Posts;
+
+export declare namespace Transactions {
+  export {
+    type TransactionCreateTransactionResponse as TransactionCreateTransactionResponse,
+    type TransactionGetTransactionEntriesResponse as TransactionGetTransactionEntriesResponse,
+    type TransactionListBadgeUsersResponse as TransactionListBadgeUsersResponse,
+    type TransactionListRuleChainsResponse as TransactionListRuleChainsResponse,
+    type TransactionResetLoyaltyCurrencyResponse as TransactionResetLoyaltyCurrencyResponse,
+    type TransactionCreateTransactionParams as TransactionCreateTransactionParams,
+    type TransactionGetTransactionEntriesParams as TransactionGetTransactionEntriesParams,
+    type TransactionListBadgeUsersParams as TransactionListBadgeUsersParams,
+    type TransactionListRuleChainsParams as TransactionListRuleChainsParams,
+    type TransactionResetLoyaltyCurrencyParams as TransactionResetLoyaltyCurrencyParams,
+  };
+
+  export {
+    RuleStatuses as RuleStatuses,
+    type RuleStatusUpdateResponse as RuleStatusUpdateResponse,
+    type RuleStatusListResponse as RuleStatusListResponse,
+    type RuleStatusUpdateParams as RuleStatusUpdateParams,
+    type RuleStatusListParams as RuleStatusListParams,
+  };
+
+  export {
+    Posts as Posts,
+    type PostListResponse as PostListResponse,
+    type PostRewardResponse as PostRewardResponse,
+    type PostListParams as PostListParams,
+    type PostRewardParams as PostRewardParams,
+  };
+}