@indiciaosint/sdk 0.0.1 → 1.0.1-patch

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

@@ -0,0 +1,1440 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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;
+};
+
+/**
+ * Search successful
+ */
+export type SearchTiktokResponse = {
+  data: SearchTiktokData3;
+  success: boolean;
+  error?: string | undefined;
+};
+
+/** @internal */
+export type SearchTiktokRequest$Outbound = {
+  query: string;
+};
+
+/** @internal */
+export const SearchTiktokRequest$outboundSchema: z.ZodMiniType<
+  SearchTiktokRequest$Outbound,
+  SearchTiktokRequest
+> = z.object({
+  query: z.string(),
+});
+
+export function searchTiktokRequestToJSON(
+  searchTiktokRequest: SearchTiktokRequest,
+): string {
+  return JSON.stringify(
+    SearchTiktokRequest$outboundSchema.parse(searchTiktokRequest),
+  );
+}
+
+/** @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,
+  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(),
+});
+
+export function searchTiktokData3FromJSON(
+  jsonString: string,
+): SafeParseResult<SearchTiktokData3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchTiktokData3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchTiktokData3' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchTiktokResponse$inboundSchema: z.ZodMiniType<
+  SearchTiktokResponse,
+  unknown
+> = z.object({
+  data: z.lazy(() => SearchTiktokData3$inboundSchema),
+  success: types.boolean(),
+  error: types.optional(types.string()),
+});
+
+export function searchTiktokResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchTiktokResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchTiktokResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchTiktokResponse' from JSON`,
+  );
+}