@snagsolutions/sdk 0.1.0-alpha.214 → 0.1.0-alpha.216

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

@@ -0,0 +1,221 @@
+// 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';
+
+export class Posts extends APIResource {
+  /**
+   * Fetch social posts with pagination and filtering options. Note: Rank is
+   * calculated for top 20,000 posts only. Posts beyond this threshold will have a
+   * null rank.
+   *
+   * @example
+   * ```ts
+   * const posts =
+   *   await client.loyalty.transactions.posts.list();
+   * ```
+   */
+  list(query?: PostListParams, options?: Core.RequestOptions): Core.APIPromise<PostListResponse>;
+  list(options?: Core.RequestOptions): Core.APIPromise<PostListResponse>;
+  list(
+    query: PostListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<PostListResponse> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this._client.get('/api/loyalty/posts', { query, ...options });
+  }
+
+  /**
+   * Reward a user for their social post.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.loyalty.transactions.posts.reward('id', {
+   *     amount: 100,
+   *     loyaltyCurrencyId:
+   *       '123e4567-e89b-12d3-a456-426614174000',
+   *   });
+   * ```
+   */
+  reward(
+    id: string,
+    body: PostRewardParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<PostRewardResponse> {
+    return this._client.post(`/api/loyalty/posts/${id}/reward`, { body, ...options });
+  }
+}
+
+/**
+ * Response containing social posts with pagination info
+ */
+export interface PostListResponse {
+  data: Array<PostListResponse.Data>;
+
+  hasNextPage: boolean;
+}
+
+export namespace PostListResponse {
+  /**
+   * A social media post
+   */
+  export interface Data {
+    id: string;
+
+    authorId: string;
+
+    createdAt: string;
+
+    isSeen: boolean;
+
+    loyaltyCurrencyId: string;
+
+    loyaltyRuleId: string;
+
+    mediaType: 'image' | 'video';
+
+    platform: 'twitter' | 'tiktok';
+
+    postType: 'post' | 'comment' | 'repost';
+
+    updatedAt: string;
+
+    userId: string;
+
+    userMetadata: Data.UserMetadata;
+
+    commentCount?: number;
+
+    contentQualityScore?: number | null;
+
+    dynamicScore?: number | null;
+
+    externalIdentifier?: string | null;
+
+    latestReward?: number | null;
+
+    likeCount?: number;
+
+    manualRank?: number | null;
+
+    mediaUrl?: string;
+
+    parentPostId?: string;
+
+    postedAt?: string | null;
+
+    previewUrl?: string;
+
+    rank?: number | null;
+
+    repostCount?: number;
+
+    sentimentScore?: number | null;
+
+    text?: string;
+
+    viewCount?: number;
+  }
+
+  export namespace Data {
+    export interface UserMetadata {
+      twitterUser: string;
+
+      twitterUserFollowersCount: number;
+
+      twitterUserId: string;
+
+      twitterVerifiedAccount: boolean;
+
+      userId: string;
+
+      logoUrl?: string;
+    }
+  }
+}
+
+/**
+ * Response containing the reward transaction details
+ */
+export interface PostRewardResponse {
+  success: boolean;
+
+  transaction: PostRewardResponse.Transaction;
+}
+
+export namespace PostRewardResponse {
+  export interface Transaction {
+    id: string;
+
+    amount: number;
+
+    loyaltyCurrencyId: string;
+  }
+}
+
+export interface PostListParams {
+  /**
+   * Cursor for pagination
+   */
+  cursor?: string;
+
+  /**
+   * Number of posts to fetch per page
+   */
+  limit?: number;
+
+  /**
+   * Optional UUID of the loyalty post to filter posts
+   */
+  loyaltyPostId?: string | Array<string>;
+
+  /**
+   * UUID of the organization to fetch social posts for
+   */
+  organizationId?: string;
+
+  /**
+   * Sort posts by createdAt or rank
+   */
+  sortBy?: 'rank' | 'createdAt';
+
+  /**
+   * Optional UUID of the user group to filter posts
+   */
+  userGroupId?: string;
+
+  /**
+   * Optional UUID of the user to filter posts
+   */
+  userId?: string | Array<string>;
+
+  /**
+   * UUID of the website to fetch social posts for
+   */
+  websiteId?: string;
+}
+
+export interface PostRewardParams {
+  /**
+   * Amount to reward
+   */
+  amount: number;
+
+  /**
+   * UUID of the loyalty currency to reward with
+   */
+  loyaltyCurrencyId: string;
+}
+
+export declare namespace Posts {
+  export {
+    type PostListResponse as PostListResponse,
+    type PostRewardResponse as PostRewardResponse,
+    type PostListParams as PostListParams,
+    type PostRewardParams as PostRewardParams,
+  };
+}

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

@@ -3,6 +3,8 @@
 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,
@@ -14,6 +16,7 @@ import {
 
 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.
@@ -61,6 +64,24 @@ export class Transactions extends APIResource {
     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
    *
@@ -79,6 +100,26 @@ export class Transactions extends APIResource {
   ): 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 {
@@ -238,6 +279,83 @@ export namespace TransactionGetTransactionEntriesResponse {
   }
 }
 
+/**
+ * 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>;
 
@@ -346,6 +464,10 @@ export namespace TransactionListRuleChainsResponse {
   }
 }
 
+export interface TransactionResetLoyaltyCurrencyResponse {
+  success: boolean;
+}
+
 export interface TransactionCreateTransactionParams {
   /**
    * Description of the loyalty transaction
@@ -509,7 +631,6 @@ export interface TransactionGetTransactionEntriesParams {
     | 'connected_reddit'
     | 'reddit_comment'
     | 'robinhood_token_hold'
-    | 'shopify_purchase'
     | Array<
         | 'Bonus'
         | 'BoughtOn'
@@ -588,7 +709,6 @@ export interface TransactionGetTransactionEntriesParams {
         | 'connected_reddit'
         | 'reddit_comment'
         | 'robinhood_token_hold'
-        | 'shopify_purchase'
       >;
 
   /**
@@ -659,6 +779,43 @@ export interface TransactionGetTransactionEntriesParams {
   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
@@ -681,16 +838,43 @@ export interface TransactionListRuleChainsParams {
   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 {
@@ -700,4 +884,12 @@ export declare namespace Transactions {
     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,
+  };
 }

package/src/resources/minting/allowlist.ts

@@ -0,0 +1,116 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class Allowlist extends APIResource {
+  /**
+   * Fetch allowlist entries for a minting contract asset
+   *
+   * @example
+   * ```ts
+   * const allowlists = await client.minting.allowlist.list({
+   *   mintingContractAssetId:
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   * });
+   * ```
+   */
+  list(query: AllowlistListParams, options?: Core.RequestOptions): Core.APIPromise<AllowlistListResponse> {
+    return this._client.get('/api/minting/assets/allowlist', { query, ...options });
+  }
+
+  /**
+   * Create or update allowlist entries for a minting contract asset (max 25 entries
+   * per request). If an entry already exists, it will be updated with the new
+   * quantity.
+   *
+   * @example
+   * ```ts
+   * const response = await client.minting.allowlist.upsert({
+   *   entries: [
+   *     { quantity: 1, walletAddress: 'walletAddress' },
+   *   ],
+   *   mintingContractAssetId:
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   * });
+   * ```
+   */
+  upsert(
+    body: AllowlistUpsertParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<AllowlistUpsertResponse> {
+    return this._client.post('/api/minting/assets/allowlist', { body, ...options });
+  }
+}
+
+/**
+ * Response schema for allowlist entries
+ */
+export interface AllowlistListResponse {
+  data: Array<AllowlistListResponse.Data>;
+
+  hasNextPage: boolean;
+}
+
+export namespace AllowlistListResponse {
+  export interface Data {
+    mintingContractAssetId: string;
+
+    quantityMinted: number;
+
+    totalQuantity: number;
+
+    walletAddress: string;
+  }
+}
+
+/**
+ * Response schema for allowlist mutations
+ */
+export interface AllowlistUpsertResponse {
+  createdCount: number;
+
+  mintingContractAssetId: string;
+}
+
+export interface AllowlistListParams {
+  mintingContractAssetId: string;
+
+  /**
+   * Number of items to return
+   */
+  limit?: number;
+
+  /**
+   * Cursor for pagination (entry ID)
+   */
+  startingAfter?: string;
+
+  walletAddress?: string;
+}
+
+export interface AllowlistUpsertParams {
+  /**
+   * Allowlist entries (max 25 per request)
+   */
+  entries: Array<AllowlistUpsertParams.Entry>;
+
+  mintingContractAssetId: string;
+}
+
+export namespace AllowlistUpsertParams {
+  export interface Entry {
+    quantity: number;
+
+    walletAddress: string;
+  }
+}
+
+export declare namespace Allowlist {
+  export {
+    type AllowlistListResponse as AllowlistListResponse,
+    type AllowlistUpsertResponse as AllowlistUpsertResponse,
+    type AllowlistListParams as AllowlistListParams,
+    type AllowlistUpsertParams as AllowlistUpsertParams,
+  };
+}

package/src/resources/minting/contracts.ts

@@ -0,0 +1,73 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class Contracts extends APIResource {
+  /**
+   * Generates a signature for minting an asset on a given contract
+   *
+   * @example
+   * ```ts
+   * const response = await client.minting.contracts.mint({
+   *   assetId: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   contractId: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   * });
+   * ```
+   */
+  mint(body: ContractMintParams, options?: Core.RequestOptions): Core.APIPromise<ContractMintResponse> {
+    return this._client.post('/api/minting/contracts/mint', { body, ...options });
+  }
+}
+
+/**
+ * Use the id returned here to fetch the status and signature of the mint from the
+ * `/api/minting/status/:id` endpoint
+ */
+export interface ContractMintResponse {
+  mintingContractAssetMintStatusId: string;
+}
+
+export interface ContractMintParams {
+  assetId: string;
+
+  contractId: string;
+
+  agreedToSendW9?: boolean | null;
+
+  customInputValue?: string | null;
+
+  emailAddress?: string;
+
+  quantity?: number;
+
+  shippingId?: string;
+
+  shippingOrderType?:
+    | 'stripe'
+    | 'shipstation'
+    | 'drip'
+    | 'twitter_bearer'
+    | 'epic_games'
+    | 'stardust'
+    | 'twitter_clientsecret'
+    | 'immutable_passport'
+    | 'sequence'
+    | 'google'
+    | 'walletConnect'
+    | 'auth0'
+    | 'privy'
+    | 'thirdweb'
+    | 'steam'
+    | 'discord'
+    | 'google_api'
+    | 'shopify'
+    | 'ultra'
+    | 'github';
+
+  walletAddress?: string;
+}
+
+export declare namespace Contracts {
+  export { type ContractMintResponse as ContractMintResponse, type ContractMintParams as ContractMintParams };
+}

package/src/resources/minting/index.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Allowlist,
+  type AllowlistListResponse,
+  type AllowlistUpsertResponse,
+  type AllowlistListParams,
+  type AllowlistUpsertParams,
+} from './allowlist';
+export { Contracts, type ContractMintResponse, type ContractMintParams } from './contracts';
+export {
+  Minting,
+  type MintingGetAssetsResponse,
+  type MintingGetTokenGateStatusResponse,
+  type MintingGetAssetsParams,
+  type MintingGetTokenGateStatusParams,
+} from './minting';
+export {
+  Status,
+  type StatusRetrieveResponse,
+  type StatusUpdateResponse,
+  type StatusUpdateParams,
+} from './status';