@indiciaosint/sdk 1.0.1-patch → 1.0.3

package/src/models/operations/search-tiktok.ts

@@ -3,304 +3,41 @@
  */
 
 import * as z from "zod/v4-mini";
-import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import * as openEnums from "../../types/enums.js";
-import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
-import { smartUnion } from "../../types/smart-union.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type SearchTiktokRequest = {
   query: string;
 };
 
-export type GeoIndicators = {
-  top10LanguagesInDescription: Array<string>;
-  top10RegionsFromVideos: Array<string>;
-};
-
-export type PerformanceByDay = {
-  avgViews: number;
-  posts: number;
-  totalEngagement: number;
-  totalViews: number;
-};
-
-export type PerformanceByHour = {
-  avgViews: number;
-  posts: number;
-  totalEngagement: number;
-  totalViews: number;
-};
-
-export type PostingFrequency = {
-  averagePostsPerWeek?: number | undefined;
-  postingConsistencyScore?: number | undefined;
-};
-
-export type PostingSchedule = {
-  mostActiveDay: string;
-  mostActiveHourUtc: string;
-  optimalPostingDay: string;
-  optimalPostingHourUtc: string;
-  performanceByDay: { [k: string]: PerformanceByDay };
-  performanceByHour: { [k: string]: PerformanceByHour };
-  postingHeatmapDayVsHourUtc: { [k: string]: { [k: string]: number } };
-  postingFrequency?: PostingFrequency | undefined;
-};
-
-export type AudienceAndTimingInsights = {
-  geoIndicators: GeoIndicators;
-  postingSchedule: PostingSchedule;
-};
-
-export type TrendingHashtag = {
-  hashtag: string;
-  olderUsage: number;
-  recentUsage: number;
-  trendScore: number;
-};
-
-export type ContentTrends = {
-  contentConsistencyScore: number;
-  recentPopularHashtags: Array<string>;
-  trendingHashtags: Array<TrendingHashtag>;
-};
-
-export type VideoLengthAnalysisSeconds = {
-  averageDuration: number;
-  longestDuration: number;
-  optimalDurationRange: string;
-  shortestDuration: number;
-};
-
-export type ContentStrategyDeepDive = {
-  contentTrends: ContentTrends;
-  top10EffectsUsed: Array<string>;
-  top10MusicTitlesUsed: Array<string>;
-  top15HashtagsUsed: Array<string>;
-  videoLengthAnalysisSeconds: VideoLengthAnalysisSeconds;
-};
-
-export type AccountStatistics = {
-  followersCount: number;
-  followingCount: number;
-  totalLikesReceivedOnAllVideos: number;
-};
-
-export type AveragePerformancePerVideo = {
-  avgComments: number;
-  avgFavorites: number;
-  avgLikes: number;
-  avgShares: number;
-  avgViews: number;
-};
-
-export type EngagementRatePerFollower = {
-  explanation: string;
-  value: string;
-};
-
-export type EngagementRatePerView = {
-  explanation: string;
-  value: string;
-};
-
-export type EngagementRatios = {
-  commentToViewRatio: string;
-  engagementRatePerFollower: EngagementRatePerFollower;
-  engagementRatePerView: EngagementRatePerView;
-  favoriteToViewRatio: string;
-  likeToViewRatio: string;
-  shareToViewRatio: string;
-};
-
-export type PerformanceSummaryAcrossAnalyzedVideos = {
-  totalComments: number;
-  totalFavorites: number;
-  totalLikes: number;
-  totalShares: number;
-  totalVideosAnalyzed: number;
-  totalViews: number;
-};
-
-export type KeyMetrics = {
-  accountStatistics: AccountStatistics;
-  averagePerformancePerVideo: AveragePerformancePerVideo;
-  engagementRatios: EngagementRatios;
-  performanceSummaryAcrossAnalyzedVideos:
-    PerformanceSummaryAcrossAnalyzedVideos;
-};
-
-export const IsPrivateAccount = {
-  No: "No",
-  Yes: "Yes",
-} as const;
-export type IsPrivateAccount = OpenEnum<typeof IsPrivateAccount>;
-
-export type ProfileSummary = {
-  isPrivateAccount: IsPrivateAccount;
-  nickname: string;
-  signature: string;
-  username: string;
-};
-
-export type HistoricalPerformance = {
-  avgComments: number;
-  avgLikes: number;
-  avgShares: number;
-  avgViews: number;
-  engagementRate: string;
-};
-
-export type RecentPerformance = {
-  avgComments: number;
-  avgLikes: number;
-  avgShares: number;
-  avgViews: number;
-  engagementRate: string;
-};
-
-export type DetailedMetrics = {
-  historicalPerformance: HistoricalPerformance;
-  recentPerformance: RecentPerformance;
-};
-
-export type ShadowBanRiskAssessmentResult = {
-  assessment: string;
-  confidenceLevel: string;
-  detailedMetrics: DetailedMetrics;
-  probabilityPercentage: string;
-  reasoning: string;
-};
-
-export type ShadowBanRiskAssessment = {
-  explanation: string;
-  result: ShadowBanRiskAssessmentResult;
-};
-
-export type ByComment = {
-  createdDate: string;
-  description: string;
-  engagementRate: string;
-  value: number;
-  videoId: string;
-  videoUrl: string;
-};
-
-export type ByLike = {
-  createdDate: string;
-  description: string;
-  engagementRate: string;
-  value: number;
-  videoId: string;
-  videoUrl: string;
-};
-
-export type ByShare = {
-  createdDate: string;
-  description: string;
-  engagementRate: string;
-  value: number;
-  videoId: string;
-  videoUrl: string;
-};
-
-export type ByView = {
-  createdDate: string;
-  description: string;
-  engagementRate: string;
-  value: number;
-  videoId: string;
-  videoUrl: string;
-};
-
-export type TopPerformingVideosSnapshot = {
-  byComments: Array<ByComment>;
-  byLikes: Array<ByLike>;
-  byShares: Array<ByShare>;
-  byViews: Array<ByView>;
-};
-
-export type BestPerformingVideo = {
-  likes: number;
-  videoId: string;
-  views: number;
-};
-
-export type ViralPotentialAnalysisResult = {
-  assessment: string;
-  bestPerformingVideo: BestPerformingVideo;
-  factors: Array<string>;
-  score: number;
-  viralVideosCount: number;
-};
-
-export type ViralPotentialAnalysis = {
-  explanation: string;
-  result: ViralPotentialAnalysisResult;
-};
-
-export type SearchTiktokData2 = {
-  audienceAndTimingInsights: AudienceAndTimingInsights;
-  contentStrategyDeepDive: ContentStrategyDeepDive;
-  keyMetrics: KeyMetrics;
-  profileSummary: ProfileSummary;
-  reportGeneratedUtc: string;
-  shadowBanRiskAssessment: ShadowBanRiskAssessment;
-  topPerformingVideosSnapshot: TopPerformingVideosSnapshot;
-  viralPotentialAnalysis: ViralPotentialAnalysis;
-};
-
-export type SearchTiktokProfile = {
-  accountCreated: string;
-  avatarURL: string;
-  bioLink: string;
-  country: string;
-  language: string;
-  nicknameLastModified: string;
-  nickname: string;
-  secUID: string;
-  userID: string;
-  usernameLastModified: string;
-  username: string;
-  about?: string | undefined;
-};
-
-export type SearchTiktokStats = {
-  followers: string;
-  following: string;
-  friends: string;
-  hearts: string;
-  videos: string;
-};
-
-export type SearchTiktokData1 = {
-  profile?: SearchTiktokProfile | undefined;
-  stats?: SearchTiktokStats | undefined;
-};
-
-export type SearchTiktokDataUnion = SearchTiktokData2 | SearchTiktokData1;
-
-export const SearchType = {
-  Basic: "basic",
-  Full: "full",
-} as const;
-export type SearchType = OpenEnum<typeof SearchType>;
-
-export type SearchTiktokData3 = {
-  data: Array<SearchTiktokData2 | SearchTiktokData1>;
-  searchType: SearchType;
-  success: boolean;
+export type SearchTiktokData = {
+  bio?: string | undefined;
+  commerce?: boolean | undefined;
+  created?: number | undefined;
+  display?: string | undefined;
+  error?: string | undefined;
+  followers?: string | undefined;
+  following?: string | undefined;
+  friends?: string | undefined;
+  id?: string | undefined;
+  language?: string | undefined;
+  likes?: string | undefined;
+  picture?: string | undefined;
+  private?: boolean | undefined;
+  region?: string | undefined;
+  ttseller?: boolean | undefined;
+  username?: string | undefined;
+  verified?: boolean | undefined;
+  videos?: string | undefined;
 };
 
 /**
  * Search successful
  */
 export type SearchTiktokResponse = {
-  data: SearchTiktokData3;
+  data: SearchTiktokData;
   success: boolean;
   error?: string | undefined;
 };
@@ -327,1095 +64,37 @@ export function searchTiktokRequestToJSON(
 }
 
 /** @internal */
-export const GeoIndicators$inboundSchema: z.ZodMiniType<
-  GeoIndicators,
-  unknown
-> = z.pipe(
-  z.object({
-    top_10_languages_in_description: z.array(types.string()),
-    top_10_regions_from_videos: z.array(types.string()),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "top_10_languages_in_description": "top10LanguagesInDescription",
-      "top_10_regions_from_videos": "top10RegionsFromVideos",
-    });
-  }),
-);
-
-export function geoIndicatorsFromJSON(
-  jsonString: string,
-): SafeParseResult<GeoIndicators, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GeoIndicators$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GeoIndicators' from JSON`,
-  );
-}
-
-/** @internal */
-export const PerformanceByDay$inboundSchema: z.ZodMiniType<
-  PerformanceByDay,
-  unknown
-> = z.object({
-  avgViews: types.number(),
-  posts: types.number(),
-  totalEngagement: types.number(),
-  totalViews: types.number(),
-});
-
-export function performanceByDayFromJSON(
-  jsonString: string,
-): SafeParseResult<PerformanceByDay, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PerformanceByDay$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PerformanceByDay' from JSON`,
-  );
-}
-
-/** @internal */
-export const PerformanceByHour$inboundSchema: z.ZodMiniType<
-  PerformanceByHour,
-  unknown
-> = z.object({
-  avgViews: types.number(),
-  posts: types.number(),
-  totalEngagement: types.number(),
-  totalViews: types.number(),
-});
-
-export function performanceByHourFromJSON(
-  jsonString: string,
-): SafeParseResult<PerformanceByHour, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PerformanceByHour$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PerformanceByHour' from JSON`,
-  );
-}
-
-/** @internal */
-export const PostingFrequency$inboundSchema: z.ZodMiniType<
-  PostingFrequency,
-  unknown
-> = z.pipe(
-  z.object({
-    average_posts_per_week: types.optional(types.number()),
-    posting_consistency_score: types.optional(types.number()),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "average_posts_per_week": "averagePostsPerWeek",
-      "posting_consistency_score": "postingConsistencyScore",
-    });
-  }),
-);
-
-export function postingFrequencyFromJSON(
-  jsonString: string,
-): SafeParseResult<PostingFrequency, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PostingFrequency$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PostingFrequency' from JSON`,
-  );
-}
-
-/** @internal */
-export const PostingSchedule$inboundSchema: z.ZodMiniType<
-  PostingSchedule,
-  unknown
-> = z.pipe(
-  z.object({
-    most_active_day: types.string(),
-    most_active_hour_utc: types.string(),
-    optimal_posting_day: types.string(),
-    optimal_posting_hour_utc: types.string(),
-    performance_by_day: z.record(
-      z.string(),
-      z.lazy(() => PerformanceByDay$inboundSchema),
-    ),
-    performance_by_hour: z.record(
-      z.string(),
-      z.lazy(() => PerformanceByHour$inboundSchema),
-    ),
-    posting_heatmap_day_vs_hour_utc: z.record(
-      z.string(),
-      z.record(z.string(), types.number()),
-    ),
-    posting_frequency: types.optional(
-      z.lazy(() => PostingFrequency$inboundSchema),
-    ),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "most_active_day": "mostActiveDay",
-      "most_active_hour_utc": "mostActiveHourUtc",
-      "optimal_posting_day": "optimalPostingDay",
-      "optimal_posting_hour_utc": "optimalPostingHourUtc",
-      "performance_by_day": "performanceByDay",
-      "performance_by_hour": "performanceByHour",
-      "posting_heatmap_day_vs_hour_utc": "postingHeatmapDayVsHourUtc",
-      "posting_frequency": "postingFrequency",
-    });
-  }),
-);
-
-export function postingScheduleFromJSON(
-  jsonString: string,
-): SafeParseResult<PostingSchedule, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => PostingSchedule$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PostingSchedule' from JSON`,
-  );
-}
-
-/** @internal */
-export const AudienceAndTimingInsights$inboundSchema: z.ZodMiniType<
-  AudienceAndTimingInsights,
-  unknown
-> = z.pipe(
-  z.object({
-    geo_indicators: z.lazy(() => GeoIndicators$inboundSchema),
-    posting_schedule: z.lazy(() => PostingSchedule$inboundSchema),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "geo_indicators": "geoIndicators",
-      "posting_schedule": "postingSchedule",
-    });
-  }),
-);
-
-export function audienceAndTimingInsightsFromJSON(
-  jsonString: string,
-): SafeParseResult<AudienceAndTimingInsights, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AudienceAndTimingInsights$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AudienceAndTimingInsights' from JSON`,
-  );
-}
-
-/** @internal */
-export const TrendingHashtag$inboundSchema: z.ZodMiniType<
-  TrendingHashtag,
-  unknown
-> = z.pipe(
-  z.object({
-    hashtag: types.string(),
-    older_usage: types.number(),
-    recent_usage: types.number(),
-    trend_score: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "older_usage": "olderUsage",
-      "recent_usage": "recentUsage",
-      "trend_score": "trendScore",
-    });
-  }),
-);
-
-export function trendingHashtagFromJSON(
-  jsonString: string,
-): SafeParseResult<TrendingHashtag, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => TrendingHashtag$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'TrendingHashtag' from JSON`,
-  );
-}
-
-/** @internal */
-export const ContentTrends$inboundSchema: z.ZodMiniType<
-  ContentTrends,
-  unknown
-> = z.pipe(
-  z.object({
-    content_consistency_score: types.number(),
-    recent_popular_hashtags: z.array(types.string()),
-    trending_hashtags: z.array(z.lazy(() => TrendingHashtag$inboundSchema)),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "content_consistency_score": "contentConsistencyScore",
-      "recent_popular_hashtags": "recentPopularHashtags",
-      "trending_hashtags": "trendingHashtags",
-    });
-  }),
-);
-
-export function contentTrendsFromJSON(
-  jsonString: string,
-): SafeParseResult<ContentTrends, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ContentTrends$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ContentTrends' from JSON`,
-  );
-}
-
-/** @internal */
-export const VideoLengthAnalysisSeconds$inboundSchema: z.ZodMiniType<
-  VideoLengthAnalysisSeconds,
-  unknown
-> = z.pipe(
-  z.object({
-    average_duration: types.number(),
-    longest_duration: types.number(),
-    optimal_duration_range: types.string(),
-    shortest_duration: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "average_duration": "averageDuration",
-      "longest_duration": "longestDuration",
-      "optimal_duration_range": "optimalDurationRange",
-      "shortest_duration": "shortestDuration",
-    });
-  }),
-);
-
-export function videoLengthAnalysisSecondsFromJSON(
-  jsonString: string,
-): SafeParseResult<VideoLengthAnalysisSeconds, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => VideoLengthAnalysisSeconds$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'VideoLengthAnalysisSeconds' from JSON`,
-  );
-}
-
-/** @internal */
-export const ContentStrategyDeepDive$inboundSchema: z.ZodMiniType<
-  ContentStrategyDeepDive,
-  unknown
-> = z.pipe(
-  z.object({
-    content_trends: z.lazy(() => ContentTrends$inboundSchema),
-    top_10_effects_used: z.array(types.string()),
-    top_10_music_titles_used: z.array(types.string()),
-    top_15_hashtags_used: z.array(types.string()),
-    video_length_analysis_seconds: z.lazy(() =>
-      VideoLengthAnalysisSeconds$inboundSchema
-    ),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "content_trends": "contentTrends",
-      "top_10_effects_used": "top10EffectsUsed",
-      "top_10_music_titles_used": "top10MusicTitlesUsed",
-      "top_15_hashtags_used": "top15HashtagsUsed",
-      "video_length_analysis_seconds": "videoLengthAnalysisSeconds",
-    });
-  }),
-);
-
-export function contentStrategyDeepDiveFromJSON(
-  jsonString: string,
-): SafeParseResult<ContentStrategyDeepDive, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ContentStrategyDeepDive$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ContentStrategyDeepDive' from JSON`,
-  );
-}
-
-/** @internal */
-export const AccountStatistics$inboundSchema: z.ZodMiniType<
-  AccountStatistics,
-  unknown
-> = z.pipe(
-  z.object({
-    followers_count: types.number(),
-    following_count: types.number(),
-    total_likes_received_on_all_videos: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "followers_count": "followersCount",
-      "following_count": "followingCount",
-      "total_likes_received_on_all_videos": "totalLikesReceivedOnAllVideos",
-    });
-  }),
-);
-
-export function accountStatisticsFromJSON(
-  jsonString: string,
-): SafeParseResult<AccountStatistics, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AccountStatistics$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AccountStatistics' from JSON`,
-  );
-}
-
-/** @internal */
-export const AveragePerformancePerVideo$inboundSchema: z.ZodMiniType<
-  AveragePerformancePerVideo,
-  unknown
-> = z.pipe(
-  z.object({
-    avg_comments: types.number(),
-    avg_favorites: types.number(),
-    avg_likes: types.number(),
-    avg_shares: types.number(),
-    avg_views: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "avg_comments": "avgComments",
-      "avg_favorites": "avgFavorites",
-      "avg_likes": "avgLikes",
-      "avg_shares": "avgShares",
-      "avg_views": "avgViews",
-    });
-  }),
-);
-
-export function averagePerformancePerVideoFromJSON(
-  jsonString: string,
-): SafeParseResult<AveragePerformancePerVideo, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AveragePerformancePerVideo$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AveragePerformancePerVideo' from JSON`,
-  );
-}
-
-/** @internal */
-export const EngagementRatePerFollower$inboundSchema: z.ZodMiniType<
-  EngagementRatePerFollower,
-  unknown
-> = z.object({
-  explanation: types.string(),
-  value: types.string(),
-});
-
-export function engagementRatePerFollowerFromJSON(
-  jsonString: string,
-): SafeParseResult<EngagementRatePerFollower, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EngagementRatePerFollower$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EngagementRatePerFollower' from JSON`,
-  );
-}
-
-/** @internal */
-export const EngagementRatePerView$inboundSchema: z.ZodMiniType<
-  EngagementRatePerView,
+export const SearchTiktokData$inboundSchema: z.ZodMiniType<
+  SearchTiktokData,
   unknown
 > = z.object({
-  explanation: types.string(),
-  value: types.string(),
-});
-
-export function engagementRatePerViewFromJSON(
-  jsonString: string,
-): SafeParseResult<EngagementRatePerView, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EngagementRatePerView$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EngagementRatePerView' from JSON`,
-  );
-}
-
-/** @internal */
-export const EngagementRatios$inboundSchema: z.ZodMiniType<
-  EngagementRatios,
-  unknown
-> = z.pipe(
-  z.object({
-    comment_to_view_ratio: types.string(),
-    engagement_rate_per_follower: z.lazy(() =>
-      EngagementRatePerFollower$inboundSchema
-    ),
-    engagement_rate_per_view: z.lazy(() => EngagementRatePerView$inboundSchema),
-    favorite_to_view_ratio: types.string(),
-    like_to_view_ratio: types.string(),
-    share_to_view_ratio: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "comment_to_view_ratio": "commentToViewRatio",
-      "engagement_rate_per_follower": "engagementRatePerFollower",
-      "engagement_rate_per_view": "engagementRatePerView",
-      "favorite_to_view_ratio": "favoriteToViewRatio",
-      "like_to_view_ratio": "likeToViewRatio",
-      "share_to_view_ratio": "shareToViewRatio",
-    });
-  }),
-);
-
-export function engagementRatiosFromJSON(
-  jsonString: string,
-): SafeParseResult<EngagementRatios, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => EngagementRatios$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EngagementRatios' from JSON`,
-  );
-}
-
-/** @internal */
-export const PerformanceSummaryAcrossAnalyzedVideos$inboundSchema:
-  z.ZodMiniType<PerformanceSummaryAcrossAnalyzedVideos, unknown> = z.pipe(
-    z.object({
-      total_comments: types.number(),
-      total_favorites: types.number(),
-      total_likes: types.number(),
-      total_shares: types.number(),
-      total_videos_analyzed: types.number(),
-      total_views: types.number(),
-    }),
-    z.transform((v) => {
-      return remap$(v, {
-        "total_comments": "totalComments",
-        "total_favorites": "totalFavorites",
-        "total_likes": "totalLikes",
-        "total_shares": "totalShares",
-        "total_videos_analyzed": "totalVideosAnalyzed",
-        "total_views": "totalViews",
-      });
-    }),
-  );
-
-export function performanceSummaryAcrossAnalyzedVideosFromJSON(
-  jsonString: string,
-): SafeParseResult<PerformanceSummaryAcrossAnalyzedVideos, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      PerformanceSummaryAcrossAnalyzedVideos$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PerformanceSummaryAcrossAnalyzedVideos' from JSON`,
-  );
-}
-
-/** @internal */
-export const KeyMetrics$inboundSchema: z.ZodMiniType<KeyMetrics, unknown> = z
-  .pipe(
-    z.object({
-      account_statistics: z.lazy(() => AccountStatistics$inboundSchema),
-      average_performance_per_video: z.lazy(() =>
-        AveragePerformancePerVideo$inboundSchema
-      ),
-      engagement_ratios: z.lazy(() => EngagementRatios$inboundSchema),
-      performance_summary_across_analyzed_videos: z.lazy(() =>
-        PerformanceSummaryAcrossAnalyzedVideos$inboundSchema
-      ),
-    }),
-    z.transform((v) => {
-      return remap$(v, {
-        "account_statistics": "accountStatistics",
-        "average_performance_per_video": "averagePerformancePerVideo",
-        "engagement_ratios": "engagementRatios",
-        "performance_summary_across_analyzed_videos":
-          "performanceSummaryAcrossAnalyzedVideos",
-      });
-    }),
-  );
-
-export function keyMetricsFromJSON(
-  jsonString: string,
-): SafeParseResult<KeyMetrics, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => KeyMetrics$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'KeyMetrics' from JSON`,
-  );
-}
-
-/** @internal */
-export const IsPrivateAccount$inboundSchema: z.ZodMiniType<
-  IsPrivateAccount,
-  unknown
-> = openEnums.inboundSchema(IsPrivateAccount);
-
-/** @internal */
-export const ProfileSummary$inboundSchema: z.ZodMiniType<
-  ProfileSummary,
-  unknown
-> = z.pipe(
-  z.object({
-    is_private_account: IsPrivateAccount$inboundSchema,
-    nickname: types.string(),
-    signature: types.string(),
-    username: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "is_private_account": "isPrivateAccount",
-    });
-  }),
-);
-
-export function profileSummaryFromJSON(
-  jsonString: string,
-): SafeParseResult<ProfileSummary, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ProfileSummary$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ProfileSummary' from JSON`,
-  );
-}
-
-/** @internal */
-export const HistoricalPerformance$inboundSchema: z.ZodMiniType<
-  HistoricalPerformance,
-  unknown
-> = z.pipe(
-  z.object({
-    avg_comments: types.number(),
-    avg_likes: types.number(),
-    avg_shares: types.number(),
-    avg_views: types.number(),
-    engagement_rate: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "avg_comments": "avgComments",
-      "avg_likes": "avgLikes",
-      "avg_shares": "avgShares",
-      "avg_views": "avgViews",
-      "engagement_rate": "engagementRate",
-    });
-  }),
-);
-
-export function historicalPerformanceFromJSON(
-  jsonString: string,
-): SafeParseResult<HistoricalPerformance, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => HistoricalPerformance$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'HistoricalPerformance' from JSON`,
-  );
-}
-
-/** @internal */
-export const RecentPerformance$inboundSchema: z.ZodMiniType<
-  RecentPerformance,
-  unknown
-> = z.pipe(
-  z.object({
-    avg_comments: types.number(),
-    avg_likes: types.number(),
-    avg_shares: types.number(),
-    avg_views: types.number(),
-    engagement_rate: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "avg_comments": "avgComments",
-      "avg_likes": "avgLikes",
-      "avg_shares": "avgShares",
-      "avg_views": "avgViews",
-      "engagement_rate": "engagementRate",
-    });
-  }),
-);
-
-export function recentPerformanceFromJSON(
-  jsonString: string,
-): SafeParseResult<RecentPerformance, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => RecentPerformance$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'RecentPerformance' from JSON`,
-  );
-}
-
-/** @internal */
-export const DetailedMetrics$inboundSchema: z.ZodMiniType<
-  DetailedMetrics,
-  unknown
-> = z.pipe(
-  z.object({
-    historical_performance: z.lazy(() => HistoricalPerformance$inboundSchema),
-    recent_performance: z.lazy(() => RecentPerformance$inboundSchema),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "historical_performance": "historicalPerformance",
-      "recent_performance": "recentPerformance",
-    });
-  }),
-);
-
-export function detailedMetricsFromJSON(
-  jsonString: string,
-): SafeParseResult<DetailedMetrics, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => DetailedMetrics$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DetailedMetrics' from JSON`,
-  );
-}
-
-/** @internal */
-export const ShadowBanRiskAssessmentResult$inboundSchema: z.ZodMiniType<
-  ShadowBanRiskAssessmentResult,
-  unknown
-> = z.pipe(
-  z.object({
-    assessment: types.string(),
-    confidence_level: types.string(),
-    detailed_metrics: z.lazy(() => DetailedMetrics$inboundSchema),
-    probability_percentage: types.string(),
-    reasoning: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "confidence_level": "confidenceLevel",
-      "detailed_metrics": "detailedMetrics",
-      "probability_percentage": "probabilityPercentage",
-    });
-  }),
-);
-
-export function shadowBanRiskAssessmentResultFromJSON(
-  jsonString: string,
-): SafeParseResult<ShadowBanRiskAssessmentResult, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ShadowBanRiskAssessmentResult$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ShadowBanRiskAssessmentResult' from JSON`,
-  );
-}
-
-/** @internal */
-export const ShadowBanRiskAssessment$inboundSchema: z.ZodMiniType<
-  ShadowBanRiskAssessment,
-  unknown
-> = z.object({
-  explanation: types.string(),
-  result: z.lazy(() => ShadowBanRiskAssessmentResult$inboundSchema),
-});
-
-export function shadowBanRiskAssessmentFromJSON(
-  jsonString: string,
-): SafeParseResult<ShadowBanRiskAssessment, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ShadowBanRiskAssessment$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ShadowBanRiskAssessment' from JSON`,
-  );
-}
-
-/** @internal */
-export const ByComment$inboundSchema: z.ZodMiniType<ByComment, unknown> = z
-  .pipe(
-    z.object({
-      created_date: types.string(),
-      description: types.string(),
-      engagement_rate: types.string(),
-      value: types.number(),
-      video_id: types.string(),
-      video_url: types.string(),
-    }),
-    z.transform((v) => {
-      return remap$(v, {
-        "created_date": "createdDate",
-        "engagement_rate": "engagementRate",
-        "video_id": "videoId",
-        "video_url": "videoUrl",
-      });
-    }),
-  );
-
-export function byCommentFromJSON(
-  jsonString: string,
-): SafeParseResult<ByComment, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ByComment$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ByComment' from JSON`,
-  );
-}
-
-/** @internal */
-export const ByLike$inboundSchema: z.ZodMiniType<ByLike, unknown> = z.pipe(
-  z.object({
-    created_date: types.string(),
-    description: types.string(),
-    engagement_rate: types.string(),
-    value: types.number(),
-    video_id: types.string(),
-    video_url: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "created_date": "createdDate",
-      "engagement_rate": "engagementRate",
-      "video_id": "videoId",
-      "video_url": "videoUrl",
-    });
-  }),
-);
-
-export function byLikeFromJSON(
-  jsonString: string,
-): SafeParseResult<ByLike, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ByLike$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ByLike' from JSON`,
-  );
-}
-
-/** @internal */
-export const ByShare$inboundSchema: z.ZodMiniType<ByShare, unknown> = z.pipe(
-  z.object({
-    created_date: types.string(),
-    description: types.string(),
-    engagement_rate: types.string(),
-    value: types.number(),
-    video_id: types.string(),
-    video_url: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "created_date": "createdDate",
-      "engagement_rate": "engagementRate",
-      "video_id": "videoId",
-      "video_url": "videoUrl",
-    });
-  }),
-);
-
-export function byShareFromJSON(
-  jsonString: string,
-): SafeParseResult<ByShare, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ByShare$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ByShare' from JSON`,
-  );
-}
-
-/** @internal */
-export const ByView$inboundSchema: z.ZodMiniType<ByView, unknown> = z.pipe(
-  z.object({
-    created_date: types.string(),
-    description: types.string(),
-    engagement_rate: types.string(),
-    value: types.number(),
-    video_id: types.string(),
-    video_url: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "created_date": "createdDate",
-      "engagement_rate": "engagementRate",
-      "video_id": "videoId",
-      "video_url": "videoUrl",
-    });
-  }),
-);
-
-export function byViewFromJSON(
-  jsonString: string,
-): SafeParseResult<ByView, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ByView$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ByView' from JSON`,
-  );
-}
-
-/** @internal */
-export const TopPerformingVideosSnapshot$inboundSchema: z.ZodMiniType<
-  TopPerformingVideosSnapshot,
-  unknown
-> = z.pipe(
-  z.object({
-    by_comments: z.array(z.lazy(() => ByComment$inboundSchema)),
-    by_likes: z.array(z.lazy(() => ByLike$inboundSchema)),
-    by_shares: z.array(z.lazy(() => ByShare$inboundSchema)),
-    by_views: z.array(z.lazy(() => ByView$inboundSchema)),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "by_comments": "byComments",
-      "by_likes": "byLikes",
-      "by_shares": "byShares",
-      "by_views": "byViews",
-    });
-  }),
-);
-
-export function topPerformingVideosSnapshotFromJSON(
-  jsonString: string,
-): SafeParseResult<TopPerformingVideosSnapshot, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => TopPerformingVideosSnapshot$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'TopPerformingVideosSnapshot' from JSON`,
-  );
-}
-
-/** @internal */
-export const BestPerformingVideo$inboundSchema: z.ZodMiniType<
-  BestPerformingVideo,
-  unknown
-> = z.pipe(
-  z.object({
-    likes: types.number(),
-    video_id: types.string(),
-    views: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "video_id": "videoId",
-    });
-  }),
-);
-
-export function bestPerformingVideoFromJSON(
-  jsonString: string,
-): SafeParseResult<BestPerformingVideo, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => BestPerformingVideo$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'BestPerformingVideo' from JSON`,
-  );
-}
-
-/** @internal */
-export const ViralPotentialAnalysisResult$inboundSchema: z.ZodMiniType<
-  ViralPotentialAnalysisResult,
-  unknown
-> = z.pipe(
-  z.object({
-    assessment: types.string(),
-    best_performing_video: z.lazy(() => BestPerformingVideo$inboundSchema),
-    factors: z.array(types.string()),
-    score: types.number(),
-    viral_videos_count: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "best_performing_video": "bestPerformingVideo",
-      "viral_videos_count": "viralVideosCount",
-    });
-  }),
-);
-
-export function viralPotentialAnalysisResultFromJSON(
-  jsonString: string,
-): SafeParseResult<ViralPotentialAnalysisResult, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ViralPotentialAnalysisResult$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ViralPotentialAnalysisResult' from JSON`,
-  );
-}
-
-/** @internal */
-export const ViralPotentialAnalysis$inboundSchema: z.ZodMiniType<
-  ViralPotentialAnalysis,
-  unknown
-> = z.object({
-  explanation: types.string(),
-  result: z.lazy(() => ViralPotentialAnalysisResult$inboundSchema),
-});
-
-export function viralPotentialAnalysisFromJSON(
-  jsonString: string,
-): SafeParseResult<ViralPotentialAnalysis, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ViralPotentialAnalysis$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ViralPotentialAnalysis' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchTiktokData2$inboundSchema: z.ZodMiniType<
-  SearchTiktokData2,
-  unknown
-> = z.pipe(
-  z.object({
-    audience_and_timing_insights: z.lazy(() =>
-      AudienceAndTimingInsights$inboundSchema
-    ),
-    content_strategy_deep_dive: z.lazy(() =>
-      ContentStrategyDeepDive$inboundSchema
-    ),
-    key_metrics: z.lazy(() => KeyMetrics$inboundSchema),
-    profile_summary: z.lazy(() => ProfileSummary$inboundSchema),
-    report_generated_utc: types.string(),
-    shadow_ban_risk_assessment: z.lazy(() =>
-      ShadowBanRiskAssessment$inboundSchema
-    ),
-    top_performing_videos_snapshot: z.lazy(() =>
-      TopPerformingVideosSnapshot$inboundSchema
-    ),
-    viral_potential_analysis: z.lazy(() =>
-      ViralPotentialAnalysis$inboundSchema
-    ),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "audience_and_timing_insights": "audienceAndTimingInsights",
-      "content_strategy_deep_dive": "contentStrategyDeepDive",
-      "key_metrics": "keyMetrics",
-      "profile_summary": "profileSummary",
-      "report_generated_utc": "reportGeneratedUtc",
-      "shadow_ban_risk_assessment": "shadowBanRiskAssessment",
-      "top_performing_videos_snapshot": "topPerformingVideosSnapshot",
-      "viral_potential_analysis": "viralPotentialAnalysis",
-    });
-  }),
-);
-
-export function searchTiktokData2FromJSON(
-  jsonString: string,
-): SafeParseResult<SearchTiktokData2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchTiktokData2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchTiktokData2' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchTiktokProfile$inboundSchema: z.ZodMiniType<
-  SearchTiktokProfile,
-  unknown
-> = z.pipe(
-  z.object({
-    "Account Created": types.string(),
-    "Avatar URL": types.string(),
-    "Bio Link": types.string(),
-    Country: types.string(),
-    Language: types.string(),
-    "Nickname Last Modified": types.string(),
-    Nickname: types.string(),
-    SecUID: types.string(),
-    "User ID": types.string(),
-    "Username Last Modified": types.string(),
-    Username: types.string(),
-    About: types.optional(types.string()),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "Account Created": "accountCreated",
-      "Avatar URL": "avatarURL",
-      "Bio Link": "bioLink",
-      "Country": "country",
-      "Language": "language",
-      "Nickname Last Modified": "nicknameLastModified",
-      "Nickname": "nickname",
-      "SecUID": "secUID",
-      "User ID": "userID",
-      "Username Last Modified": "usernameLastModified",
-      "Username": "username",
-      "About": "about",
-    });
-  }),
-);
-
-export function searchTiktokProfileFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchTiktokProfile, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchTiktokProfile$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchTiktokProfile' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchTiktokStats$inboundSchema: z.ZodMiniType<
-  SearchTiktokStats,
-  unknown
-> = z.object({
-  followers: types.string(),
-  following: types.string(),
-  friends: types.string(),
-  hearts: types.string(),
-  videos: types.string(),
-});
-
-export function searchTiktokStatsFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchTiktokStats, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchTiktokStats$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchTiktokStats' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchTiktokData1$inboundSchema: z.ZodMiniType<
-  SearchTiktokData1,
-  unknown
-> = z.object({
-  profile: types.optional(z.lazy(() => SearchTiktokProfile$inboundSchema)),
-  stats: types.optional(z.lazy(() => SearchTiktokStats$inboundSchema)),
-});
-
-export function searchTiktokData1FromJSON(
-  jsonString: string,
-): SafeParseResult<SearchTiktokData1, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchTiktokData1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchTiktokData1' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchTiktokDataUnion$inboundSchema: z.ZodMiniType<
-  SearchTiktokDataUnion,
-  unknown
-> = smartUnion([
-  z.lazy(() => SearchTiktokData2$inboundSchema),
-  z.lazy(() => SearchTiktokData1$inboundSchema),
-]);
-
-export function searchTiktokDataUnionFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchTiktokDataUnion, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchTiktokDataUnion$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchTiktokDataUnion' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchType$inboundSchema: z.ZodMiniType<SearchType, unknown> =
-  openEnums.inboundSchema(SearchType);
-
-/** @internal */
-export const SearchTiktokData3$inboundSchema: z.ZodMiniType<
-  SearchTiktokData3,
-  unknown
-> = z.object({
-  data: z.array(
-    smartUnion([
-      z.lazy(() => SearchTiktokData2$inboundSchema),
-      z.lazy(() => SearchTiktokData1$inboundSchema),
-    ]),
-  ),
-  searchType: SearchType$inboundSchema,
-  success: types.boolean(),
+  bio: types.optional(types.string()),
+  commerce: types.optional(types.boolean()),
+  created: types.optional(types.number()),
+  display: types.optional(types.string()),
+  error: types.optional(types.string()),
+  followers: types.optional(types.string()),
+  following: types.optional(types.string()),
+  friends: types.optional(types.string()),
+  id: types.optional(types.string()),
+  language: types.optional(types.string()),
+  likes: types.optional(types.string()),
+  picture: types.optional(types.string()),
+  private: types.optional(types.boolean()),
+  region: types.optional(types.string()),
+  ttseller: types.optional(types.boolean()),
+  username: types.optional(types.string()),
+  verified: types.optional(types.boolean()),
+  videos: types.optional(types.string()),
 });
 
-export function searchTiktokData3FromJSON(
+export function searchTiktokDataFromJSON(
   jsonString: string,
-): SafeParseResult<SearchTiktokData3, SDKValidationError> {
+): SafeParseResult<SearchTiktokData, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => SearchTiktokData3$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchTiktokData3' from JSON`,
+    (x) => SearchTiktokData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchTiktokData' from JSON`,
   );
 }
 
@@ -1424,7 +103,7 @@ export const SearchTiktokResponse$inboundSchema: z.ZodMiniType<
   SearchTiktokResponse,
   unknown
 > = z.object({
-  data: z.lazy(() => SearchTiktokData3$inboundSchema),
+  data: z.lazy(() => SearchTiktokData$inboundSchema),
   success: types.boolean(),
   error: types.optional(types.string()),
 });