igpapi — Instagram private API Simulator for Node.js (API reference) 4.19.0
    Preparing search index...

    Interface SearchInputHandle

    The handle of SearchInputScreen: what you hold while the screen is open — its data, its actions (SearchInputActions) and its lists (SearchInputItems).

    interface SearchInputHandle {
        back: ScreenBackEffect<
            AssembledHandle<
                "Explore",
                "tab",
                {
                    recent: readonly {
                        fullName?: string;
                        rowKey: string;
                        userId?: string;
                        username?: string;
                    }[];
                },
                ExploreActions,
                Record<never, never>,
                ScreenHandle,
                "optional",
                false,
                never,
                unknown,
            >,
        >;
        change: <Self extends ScreenHandle>(
            this: Self,
            ...args: [query: string],
        ) => Effect<
            Self,
            ScreenDataActionFailure<
                | IgApiError
                | HttpRequestError
                | SchemaError
                | GraphqlRootFieldMissingError
                | GraphqlServerError,
            >,
            never,
        >;
        checkpoint: () => Effect<
            ScreenCheckpoint<"SearchInput">,
            ScreenCheckpointFailure,
        >;
        clear: <Self extends ScreenHandle>(
            this: Self,
            ...args: [],
        ) => Effect<Self, ScreenDataActionFailure<never>, never>;
        data: {
            query: string;
            rankToken: string;
            recentAccounts: readonly {
                fullName?: string;
                rowKey: string;
                userId?: string;
                username?: string;
            }[];
            results: readonly (
                | {
                    __typename: "unknown";
                    item: { kind: "unknown"; kindKey?: string; raw: Json };
                    key: string;
                }
                | {
                    __typename: "XDTTypeaheadSearchKeyword";
                    key: string;
                    keyword_lazified: {
                        id: string;
                        name?: string;
                        user?: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    };
                }
                | {
                    __typename: "XDTTypeaheadSearchUser";
                    key: string;
                    rank_token?: string;
                    rankToken?: string;
                    user: {
                        full_name?: string;
                        id?: string;
                        is_private?: boolean;
                        is_verified?: boolean;
                        latest_reel_media?: number;
                        profile_pic_url?: string;
                        search_serp_type?: number;
                        username?: string;
                    };
                }
                | {
                    __typename: "XDTTypeaheadSearchHashtag";
                    hashtag: { id: string; media_count?: number; name?: string };
                    key: string;
                }
                | {
                    __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                    key: string;
                    keywords: readonly {
                        id: string;
                        name?: string;
                        user?: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    }[];
                    num_keywords_to_show?: number;
                    query_text: string;
                }
            )[];
            session?: {
                clientUuidRankToken: string;
                searchSessionId: string;
                serpSessionId?: string;
                typeaheadSessionId: string;
            };
        };
        id: "SearchInput";
        kind: "screen";
        openRecentAccount: (
            ...args: readonly [string],
        ) => Effect<
            AssembledHandle<
                "UserProfile",
                "screen",
                {
                    backgroundFailures: readonly {
                        message?: string;
                        request: | "story"
                        | "chaining"
                        | "recentSearchClick"
                        | "friendship"
                        | "highlights"
                        | "avatar"
                        | "inboxTray"
                        | "schoolBadge"
                        | "quickPromotion"
                        | "noteCtas"
                        | "selfProfileChaining"
                        | "creatorsTrial"
                        | "onboardingChecklist"
                        | "creatorDestinationType"
                        | "paymentsAccountDisabledRisk"
                        | "fbPayExperience"
                        | "donationsEligibility"
                        | "metaOneBenefitEligibility"
                        | "ringCreatorMetadata"
                        | "proHomeBadge"
                        | "proDashboard"
                        | "activityCount";
                        tag: string;
                    }[];
                    following?: boolean;
                    followRequested?: boolean;
                    gridCursor?: { gridItemsCursor: string; maxId: string };
                    isPrivate: boolean;
                    media: readonly {
                        authorId?: string;
                        carousel?: { children: readonly string[]; size?: number };
                        dashManifest?: string;
                        mediaId: string;
                        mediaType?: number;
                        position: number;
                        takenAt?: number;
                        trackingToken?: string;
                        videoDuration?: number;
                    }[];
                    profileSessionId: string;
                    stories: readonly {
                        id: string;
                        media_type: number;
                        pk: string;
                        taken_at?: number;
                    }[];
                    suggested: readonly {
                        followRankingToken?: string;
                        fullName: string;
                        userId: string;
                        username: string;
                    }[];
                    userId: string;
                    username: string;
                },
                ProfileActions,
                ProfileItems,
                ScreenHandle,
                "required",
                true,
                "userId",
                AndroidScreens,
            >,
            | ScreenEnterConcurrentError
            | ScreenDataError
            | ScreenEdgeInputError
            | ProfileEnterError,
            never,
        >;
        origin: AssembledHandle<
            "Explore",
            "tab",
            {
                recent: readonly {
                    fullName?: string;
                    rowKey: string;
                    userId?: string;
                    username?: string;
                }[];
            },
            ExploreActions,
            Record<never, never>,
            ScreenHandle,
            "optional",
            false,
            never,
            unknown,
        >;
        pipe: {
            <A>(this: A): A;
            <A, B = never>(this: A, ab: (_: A) => B): B;
            <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
            <A, B = never, C = never, D = never>(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
            ): D;
            <A, B = never, C = never, D = never, E = never>(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
            ): E;
            <A, B = never, C = never, D = never, E = never, F = never>(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
            ): F;
            <A, B = never, C = never, D = never, E = never, F = never, G = never>(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
            ): G;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
            ): H;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
            ): I;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
            ): J;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
            ): K;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
            ): L;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
            ): M;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
            ): N;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
            ): O;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
            ): P;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
                Q = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
                pq: (_: P) => Q,
            ): Q;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
                Q = never,
                R = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
                pq: (_: P) => Q,
                qr: (_: Q) => R,
            ): R;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
                Q = never,
                R = never,
                S = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
                pq: (_: P) => Q,
                qr: (_: Q) => R,
                rs: (_: R) => S,
            ): S;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
                Q = never,
                R = never,
                S = never,
                T = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
                pq: (_: P) => Q,
                qr: (_: Q) => R,
                rs: (_: R) => S,
                st: (_: S) => T,
            ): T;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
                Q = never,
                R = never,
                S = never,
                T = never,
                U = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
                pq: (_: P) => Q,
                qr: (_: Q) => R,
                rs: (_: R) => S,
                st: (_: S) => T,
                tu: (_: T) => U,
            ): U;
            <
                A,
                B = never,
                C = never,
                D = never,
                E = never,
                F = never,
                G = never,
                H = never,
                I = never,
                J = never,
                K = never,
                L = never,
                M = never,
                N = never,
                O = never,
                P = never,
                Q = never,
                R = never,
                S = never,
                T = never,
                U = never,
            >(
                this: A,
                ab: (_: A) => B,
                bc: (_: B) => C,
                cd: (_: C) => D,
                de: (_: D) => E,
                ef: (_: E) => F,
                fg: (_: F) => G,
                gh: (_: G) => H,
                hi: (_: H) => I,
                ij: (_: I) => J,
                jk: (_: J) => K,
                kl: (_: K) => L,
                lm: (_: L) => M,
                mn: (_: M) => N,
                no: (_: N) => O,
                op: (_: O) => P,
                pq: (_: P) => Q,
                qr: (_: Q) => R,
                rs: (_: R) => S,
                st: (_: S) => T,
                tu: (_: T) => U,
            ): U;
        };
        raw: readonly RawAnswer[];
        recentAccounts: readonly ScreenListItem<
            {
                at: "recentAccounts";
                item: ScreenItemDefinition<
                    "RecentSearchAccount",
                    {
                        fullName?: string;
                        rowKey: string;
                        userId?: string;
                        username?: string;
                    },
                    {
                        fullName?: string;
                        rowKey: string;
                        userId?: string;
                        username?: string;
                    },
                    RecentSearchAccountState,
                    never,
                    never,
                    RecentSearchAccountItemActions,
                    undefined,
                    never,
                    never,
                >;
                key: "rowKey";
                source: ScreenNoItemNodes;
            },
            AssembledHandle<
                "SearchInput",
                "screen",
                {
                    query: string;
                    rankToken: string;
                    recentAccounts: readonly {
                        fullName?: string;
                        rowKey: string;
                        userId?: string;
                        username?: string;
                    }[];
                    results: readonly (
                        | {
                            __typename: "unknown";
                            item: { kind: "unknown"; kindKey?: string; raw: Json };
                            key: string;
                        }
                        | {
                            __typename: "XDTTypeaheadSearchKeyword";
                            key: string;
                            keyword_lazified: {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: (...)
                                    | (...);
                                    id?: (...) | (...);
                                    is_private?: (...) | (...) | (...);
                                    is_verified?: (...) | (...) | (...);
                                    latest_reel_media?: (...) | (...);
                                    profile_pic_url?: (...) | (...);
                                    search_serp_type?: (...) | (...);
                                    username?: (...) | (...);
                                };
                            };
                        }
                        | {
                            __typename: "XDTTypeaheadSearchUser";
                            key: string;
                            rank_token?: string;
                            rankToken?: string;
                            user: {
                                full_name?: string;
                                id?: string;
                                is_private?: boolean;
                                is_verified?: boolean;
                                latest_reel_media?: number;
                                profile_pic_url?: string;
                                search_serp_type?: number;
                                username?: string;
                            };
                        }
                        | {
                            __typename: "XDTTypeaheadSearchHashtag";
                            hashtag: { id: string; media_count?: number; name?: string };
                            key: string;
                        }
                        | {
                            __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                            key: string;
                            keywords: readonly {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: ...;
                                    id?: ...;
                                    is_private?: ...;
                                    is_verified?: ...;
                                    latest_reel_media?: ...;
                                    profile_pic_url?: ...;
                                    search_serp_type?: ...;
                                    username?: ...;
                                };
                            }[];
                            num_keywords_to_show?: number;
                            query_text: string;
                        }
                    )[];
                    session?: {
                        clientUuidRankToken: string;
                        searchSessionId: string;
                        serpSessionId?: string;
                        typeaheadSessionId: string;
                    };
                },
                SearchInputActions,
                SearchInputItems,
                ScreenHandle,
                "required",
                true,
                never,
                AndroidScreens,
            >,
        >[];
        results: readonly ScreenListItem<
            {
                at: "results";
                by: "__typename";
                key: "key";
                source: ScreenNoItemNodes;
                variants: {
                    unknown: ScreenItemDefinition<
                        "SearchInputUnknownResult",
                        {
                            __typename: "unknown";
                            item: { kind: "unknown"; kindKey?: string; raw: Json };
                            key: string;
                        },
                        {
                            __typename: "unknown";
                            item: { kind: "unknown"; kindKey?: string; raw: Json };
                            key: string;
                        },
                        Record<never, never>,
                        never,
                        never,
                        TypeaheadUnknownResultItemActions,
                        undefined,
                        never,
                        never,
                    >;
                    XDTTypeaheadSearchHashtag: ScreenItemDefinition<
                        "SearchInputHashtagResult",
                        {
                            __typename: "XDTTypeaheadSearchHashtag";
                            hashtag: { id: string; media_count?: number; name?: string };
                            key: string;
                        },
                        {
                            __typename: "XDTTypeaheadSearchHashtag";
                            hashtag: { id: string; media_count?: number; name?: string };
                            key: string;
                        },
                        Record<never, never>,
                        never,
                        never,
                        TypeaheadHashtagResultItemActions,
                        undefined,
                        never,
                        never,
                    >;
                    XDTTypeaheadSearchKeyword: ScreenItemDefinition<
                        "SearchInputKeywordResult",
                        {
                            __typename: "XDTTypeaheadSearchKeyword";
                            key: string;
                            keyword_lazified: {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: string;
                                    id?: string;
                                    is_private?: boolean;
                                    is_verified?: boolean;
                                    latest_reel_media?: number;
                                    profile_pic_url?: string;
                                    search_serp_type?: number;
                                    username?: string;
                                };
                            };
                        },
                        {
                            __typename: "XDTTypeaheadSearchKeyword";
                            key: string;
                            keyword_lazified: {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: string;
                                    id?: string;
                                    is_private?: boolean;
                                    is_verified?: boolean;
                                    latest_reel_media?: number;
                                    profile_pic_url?: string;
                                    search_serp_type?: number;
                                    username?: string;
                                };
                            };
                        },
                        Record<never, never>,
                        never,
                        never,
                        TypeaheadKeywordResultItemActions,
                        undefined,
                        never,
                        never,
                    >;
                    XDTTypeaheadSearchOverfetchedKeywords: ScreenItemDefinition<
                        "SearchInputOverfetchedKeywordsResult",
                        {
                            __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                            key: string;
                            keywords: readonly {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: (...)
                                    | (...);
                                    id?: (...) | (...);
                                    is_private?: (...) | (...) | (...);
                                    is_verified?: (...) | (...) | (...);
                                    latest_reel_media?: (...) | (...);
                                    profile_pic_url?: (...) | (...);
                                    search_serp_type?: (...) | (...);
                                    username?: (...) | (...);
                                };
                            }[];
                            num_keywords_to_show?: number;
                            query_text: string;
                        },
                        {
                            __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                            key: string;
                            keywords: readonly {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: (...)
                                    | (...);
                                    id?: (...) | (...);
                                    is_private?: (...) | (...) | (...);
                                    is_verified?: (...) | (...) | (...);
                                    latest_reel_media?: (...) | (...);
                                    profile_pic_url?: (...) | (...);
                                    search_serp_type?: (...) | (...);
                                    username?: (...) | (...);
                                };
                            }[];
                            num_keywords_to_show?: number;
                            query_text: string;
                        },
                        Record<never, never>,
                        never,
                        never,
                        TypeaheadOverfetchedKeywordsResultItemActions,
                        undefined,
                        never,
                        never,
                    >;
                    XDTTypeaheadSearchUser: ScreenItemDefinition<
                        "SearchInputUserResult",
                        {
                            __typename: "XDTTypeaheadSearchUser";
                            key: string;
                            rank_token?: string;
                            rankToken?: string;
                            user: {
                                full_name?: string;
                                id?: string;
                                is_private?: boolean;
                                is_verified?: boolean;
                                latest_reel_media?: number;
                                profile_pic_url?: string;
                                search_serp_type?: number;
                                username?: string;
                            };
                        },
                        {
                            __typename: "XDTTypeaheadSearchUser";
                            key: string;
                            rank_token?: string;
                            rankToken?: string;
                            user: {
                                full_name?: string;
                                id?: string;
                                is_private?: boolean;
                                is_verified?: boolean;
                                latest_reel_media?: number;
                                profile_pic_url?: string;
                                search_serp_type?: number;
                                username?: string;
                            };
                        },
                        TypeaheadUserRowState,
                        never,
                        never,
                        TypeaheadUserResultItemActions,
                        undefined,
                        never,
                        never,
                    >;
                };
            },
            AssembledHandle<
                "SearchInput",
                "screen",
                {
                    query: string;
                    rankToken: string;
                    recentAccounts: readonly {
                        fullName?: string;
                        rowKey: string;
                        userId?: string;
                        username?: string;
                    }[];
                    results: readonly (
                        | {
                            __typename: "unknown";
                            item: { kind: "unknown"; kindKey?: string; raw: Json };
                            key: string;
                        }
                        | {
                            __typename: "XDTTypeaheadSearchKeyword";
                            key: string;
                            keyword_lazified: {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: (...)
                                    | (...);
                                    id?: (...) | (...);
                                    is_private?: (...) | (...) | (...);
                                    is_verified?: (...) | (...) | (...);
                                    latest_reel_media?: (...) | (...);
                                    profile_pic_url?: (...) | (...);
                                    search_serp_type?: (...) | (...);
                                    username?: (...) | (...);
                                };
                            };
                        }
                        | {
                            __typename: "XDTTypeaheadSearchUser";
                            key: string;
                            rank_token?: string;
                            rankToken?: string;
                            user: {
                                full_name?: string;
                                id?: string;
                                is_private?: boolean;
                                is_verified?: boolean;
                                latest_reel_media?: number;
                                profile_pic_url?: string;
                                search_serp_type?: number;
                                username?: string;
                            };
                        }
                        | {
                            __typename: "XDTTypeaheadSearchHashtag";
                            hashtag: { id: string; media_count?: number; name?: string };
                            key: string;
                        }
                        | {
                            __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                            key: string;
                            keywords: readonly {
                                id: string;
                                name?: string;
                                user?: {
                                    full_name?: ...;
                                    id?: ...;
                                    is_private?: ...;
                                    is_verified?: ...;
                                    latest_reel_media?: ...;
                                    profile_pic_url?: ...;
                                    search_serp_type?: ...;
                                    username?: ...;
                                };
                            }[];
                            num_keywords_to_show?: number;
                            query_text: string;
                        }
                    )[];
                    session?: {
                        clientUuidRankToken: string;
                        searchSessionId: string;
                        serpSessionId?: string;
                        typeaheadSessionId: string;
                    };
                },
                SearchInputActions,
                SearchInputItems,
                ScreenHandle,
                "required",
                true,
                never,
                AndroidScreens,
            >,
        >[];
        search: (
            ...args: readonly [string],
        ) => Effect<
            AssembledHandle<
                "SearchResultsTopTab",
                "screen",
                {
                    query: string;
                    session: {
                        clientUuidRankToken?: string;
                        searchSessionId: string;
                        serpSessionId: string;
                        typeaheadSessionId?: string;
                    };
                },
                SearchResultsTopTabActions,
                Record<never, never>,
                ScreenHandle,
                "required",
                true,
                never,
                AndroidScreens,
            >,

                | IgApiError
                | HttpRequestError
                | ScreenEnterConcurrentError
                | ScreenDataError
                | ScreenEdgeInputError,
            never,
        >;
        tail: Effect<void, SessionFatalError>;
        toJSON: () => {
            query: string;
            rankToken: string;
            recentAccounts: readonly {
                fullName?: string;
                rowKey: string;
                userId?: string;
                username?: string;
            }[];
            results: readonly (
                | {
                    __typename: "unknown";
                    item: { kind: "unknown"; kindKey?: string; raw: Json };
                    key: string;
                }
                | {
                    __typename: "XDTTypeaheadSearchKeyword";
                    key: string;
                    keyword_lazified: {
                        id: string;
                        name?: string;
                        user?: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    };
                }
                | {
                    __typename: "XDTTypeaheadSearchUser";
                    key: string;
                    rank_token?: string;
                    rankToken?: string;
                    user: {
                        full_name?: string;
                        id?: string;
                        is_private?: boolean;
                        is_verified?: boolean;
                        latest_reel_media?: number;
                        profile_pic_url?: string;
                        search_serp_type?: number;
                        username?: string;
                    };
                }
                | {
                    __typename: "XDTTypeaheadSearchHashtag";
                    hashtag: { id: string; media_count?: number; name?: string };
                    key: string;
                }
                | {
                    __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                    key: string;
                    keywords: readonly {
                        id: string;
                        name?: string;
                        user?: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    }[];
                    num_keywords_to_show?: number;
                    query_text: string;
                }
            )[];
            session?: {
                clientUuidRankToken: string;
                searchSessionId: string;
                serpSessionId?: string;
                typeaheadSessionId: string;
            };
        };
    }
    Index

    Properties

    back: ScreenBackEffect<
        AssembledHandle<
            "Explore",
            "tab",
            {
                recent: readonly {
                    fullName?: string;
                    rowKey: string;
                    userId?: string;
                    username?: string;
                }[];
            },
            ExploreActions,
            Record<never, never>,
            ScreenHandle,
            "optional",
            false,
            never,
            unknown,
        >,
    >

    Goes back, as the system back does: closes this screen and answers the screen below it, typed as the screens that can open this one.

    change: <Self extends ScreenHandle>(
        this: Self,
        ...args: [query: string],
    ) => Effect<
        Self,
        ScreenDataActionFailure<
            | IgApiError
            | HttpRequestError
            | SchemaError
            | GraphqlRootFieldMissingError
            | GraphqlServerError,
        >,
        never,
    >

    Types in the search field (query): looks the text up. Answers the field shown again over the fresh data (the query, its results and the rank token); continue from it for the next keystroke, which carries on the same typing session. A text this typing session already answered shows that answer and sends nothing.

    checkpoint: () => Effect<
        ScreenCheckpoint<"SearchInput">,
        ScreenCheckpointFailure,
    >

    Takes a checkpoint of the process with this screen on top: what a fresh process needs to continue from it (restoreCheckpoint), the stack below included, without opening any screen again.

    clear: <Self extends ScreenHandle>(
        this: Self,
        ...args: [],
    ) => Effect<Self, ScreenDataActionFailure<never>, never>

    Clears the field's text: the person tapped its clear (X). Sends no request and answers the field's live handle — the same typing session, an empty text, no suggestions, no rank token ('', the empty open's own value) and the recent accounts the field holds from its open, which an empty field shows again — so the next change starts from an empty field and carries only the new text.

    Recorded: android-451/follow-two-from-search — after the first follow the person returned to the field still holding the first name, tapped its clear once, and no request went out between the follow (#122) and the second typing (#124); the second typing's requests carry the same typeahead session id as the first's. The app registers a client event for the tap (ig_search_clear_query_x_icon_tap), not a request, and the library logs it (search.telemetry.ts); the library emits no search_viewport_view (null_state_recent) after it, because the recording logs none there.

    Observed by screenshot, not recorded: on our emulator (app 451, 2026-10-30) the field is empty right after the tap and the Recent accounts list is back with the keyboard open, and it stays so 3 s later. The packet recording carries no screen for it.

    data: {
        query: string;
        rankToken: string;
        recentAccounts: readonly {
            fullName?: string;
            rowKey: string;
            userId?: string;
            username?: string;
        }[];
        results: readonly (
            | {
                __typename: "unknown";
                item: { kind: "unknown"; kindKey?: string; raw: Json };
                key: string;
            }
            | {
                __typename: "XDTTypeaheadSearchKeyword";
                key: string;
                keyword_lazified: {
                    id: string;
                    name?: string;
                    user?: {
                        full_name?: string;
                        id?: string;
                        is_private?: boolean;
                        is_verified?: boolean;
                        latest_reel_media?: number;
                        profile_pic_url?: string;
                        search_serp_type?: number;
                        username?: string;
                    };
                };
            }
            | {
                __typename: "XDTTypeaheadSearchUser";
                key: string;
                rank_token?: string;
                rankToken?: string;
                user: {
                    full_name?: string;
                    id?: string;
                    is_private?: boolean;
                    is_verified?: boolean;
                    latest_reel_media?: number;
                    profile_pic_url?: string;
                    search_serp_type?: number;
                    username?: string;
                };
            }
            | {
                __typename: "XDTTypeaheadSearchHashtag";
                hashtag: { id: string; media_count?: number; name?: string };
                key: string;
            }
            | {
                __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                key: string;
                keywords: readonly {
                    id: string;
                    name?: string;
                    user?: {
                        full_name?: string;
                        id?: string;
                        is_private?: boolean;
                        is_verified?: boolean;
                        latest_reel_media?: number;
                        profile_pic_url?: string;
                        search_serp_type?: number;
                        username?: string;
                    };
                }[];
                num_keywords_to_show?: number;
                query_text: string;
            }
        )[];
        session?: {
            clientUuidRankToken: string;
            searchSessionId: string;
            serpSessionId?: string;
            typeaheadSessionId: string;
        };
    }

    What the screen shows: its data, as its data schema types it.

    Type Declaration

    • Readonlyquery: string
    • ReadonlyrankToken: string
    • ReadonlyrecentAccounts: readonly {
          fullName?: string;
          rowKey: string;
          userId?: string;
          username?: string;
      }[]

      The recent accounts the field lists as items while its text is empty (the ones it was opened with); a keystroke replaces them with the suggestions, and clear() lists them again.

    • Readonlyresults: readonly (
          | {
              __typename: "unknown";
              item: { kind: "unknown"; kindKey?: string; raw: Json };
              key: string;
          }
          | {
              __typename: "XDTTypeaheadSearchKeyword";
              key: string;
              keyword_lazified: {
                  id: string;
                  name?: string;
                  user?: {
                      full_name?: string;
                      id?: string;
                      is_private?: boolean;
                      is_verified?: boolean;
                      latest_reel_media?: number;
                      profile_pic_url?: string;
                      search_serp_type?: number;
                      username?: string;
                  };
              };
          }
          | {
              __typename: "XDTTypeaheadSearchUser";
              key: string;
              rank_token?: string;
              rankToken?: string;
              user: {
                  full_name?: string;
                  id?: string;
                  is_private?: boolean;
                  is_verified?: boolean;
                  latest_reel_media?: number;
                  profile_pic_url?: string;
                  search_serp_type?: number;
                  username?: string;
              };
          }
          | {
              __typename: "XDTTypeaheadSearchHashtag";
              hashtag: { id: string; media_count?: number; name?: string };
              key: string;
          }
          | {
              __typename: "XDTTypeaheadSearchOverfetchedKeywords";
              key: string;
              keywords: readonly {
                  id: string;
                  name?: string;
                  user?: {
                      full_name?: string;
                      id?: string;
                      is_private?: boolean;
                      is_verified?: boolean;
                      latest_reel_media?: number;
                      profile_pic_url?: string;
                      search_serp_type?: number;
                      username?: string;
                  };
              }[];
              num_keywords_to_show?: number;
              query_text: string;
          }
      )[]
    • Optional Readonlysession?: {
          clientUuidRankToken: string;
          searchSessionId: string;
          serpSessionId?: string;
          typeaheadSessionId: string;
      }

      The search session the field's open started (empty or typed); the typing session continues it.

    id: "SearchInput"

    Which screen this is: its id in the screen catalog (an item's: its item id).

    kind: "screen"

    What kind of thing the screen is: a screen, a tab, an inner tab, a feed or an item.

    openRecentAccount: (
        ...args: readonly [string],
    ) => Effect<
        AssembledHandle<
            "UserProfile",
            "screen",
            {
                backgroundFailures: readonly {
                    message?: string;
                    request: | "story"
                    | "chaining"
                    | "recentSearchClick"
                    | "friendship"
                    | "highlights"
                    | "avatar"
                    | "inboxTray"
                    | "schoolBadge"
                    | "quickPromotion"
                    | "noteCtas"
                    | "selfProfileChaining"
                    | "creatorsTrial"
                    | "onboardingChecklist"
                    | "creatorDestinationType"
                    | "paymentsAccountDisabledRisk"
                    | "fbPayExperience"
                    | "donationsEligibility"
                    | "metaOneBenefitEligibility"
                    | "ringCreatorMetadata"
                    | "proHomeBadge"
                    | "proDashboard"
                    | "activityCount";
                    tag: string;
                }[];
                following?: boolean;
                followRequested?: boolean;
                gridCursor?: { gridItemsCursor: string; maxId: string };
                isPrivate: boolean;
                media: readonly {
                    authorId?: string;
                    carousel?: { children: readonly string[]; size?: number };
                    dashManifest?: string;
                    mediaId: string;
                    mediaType?: number;
                    position: number;
                    takenAt?: number;
                    trackingToken?: string;
                    videoDuration?: number;
                }[];
                profileSessionId: string;
                stories: readonly {
                    id: string;
                    media_type: number;
                    pk: string;
                    taken_at?: number;
                }[];
                suggested: readonly {
                    followRankingToken?: string;
                    fullName: string;
                    userId: string;
                    username: string;
                }[];
                userId: string;
                username: string;
            },
            ProfileActions,
            ProfileItems,
            ScreenHandle,
            "required",
            true,
            "userId",
            AndroidScreens,
        >,
        | ScreenEnterConcurrentError
        | ScreenDataError
        | ScreenEdgeInputError
        | ProfileEnterError,
        never,
    >

    Opening an account of the field's Recent list by its user id, without a submit: the same walk a Recent row's openProfile takes (the account is cached, the click registers, the info stream is the bare entry_point=profile form). A scene whose person returns to the field and taps a Recent row continues from here (android-451/follow-from-search). Answers the profile handle.

    origin: AssembledHandle<
        "Explore",
        "tab",
        {
            recent: readonly {
                fullName?: string;
                rowKey: string;
                userId?: string;
                username?: string;
            }[];
        },
        ExploreActions,
        Record<never, never>,
        ScreenHandle,
        "optional",
        false,
        never,
        unknown,
    >

    The handle this one was opened from: the screen (or the item of its list) whose call opened it, typed as what can open this screen; undefined for a launch's or a tab's root.

    pipe: {
        <A>(this: A): A;
        <A, B = never>(this: A, ab: (_: A) => B): B;
        <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
        <A, B = never, C = never, D = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
        ): D;
        <A, B = never, C = never, D = never, E = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
        ): E;
        <A, B = never, C = never, D = never, E = never, F = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
        ): F;
        <A, B = never, C = never, D = never, E = never, F = never, G = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
        ): G;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
        ): H;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
        ): I;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
        ): J;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
        ): K;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
        ): L;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
        ): M;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
        ): N;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
        ): O;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
        ): P;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
        ): Q;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
        ): R;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
        ): S;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
            T = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
            st: (_: S) => T,
        ): T;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
            T = never,
            U = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
            st: (_: S) => T,
            tu: (_: T) => U,
        ): U;
        <
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
            T = never,
            U = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
            st: (_: S) => T,
            tu: (_: T) => U,
        ): U;
    }

    Passes the handle through the functions you give, left to right: handle.pipe(f, g) is g(f(handle)).

    raw: readonly RawAnswer[]

    The answers this visit received from the server, before any decoding; empty on a handle a checkpoint rebuilt.

    recentAccounts: readonly ScreenListItem<
        {
            at: "recentAccounts";
            item: ScreenItemDefinition<
                "RecentSearchAccount",
                { fullName?: string; rowKey: string; userId?: string; username?: string },
                { fullName?: string; rowKey: string; userId?: string; username?: string },
                RecentSearchAccountState,
                never,
                never,
                RecentSearchAccountItemActions,
                undefined,
                never,
                never,
            >;
            key: "rowKey";
            source: ScreenNoItemNodes;
        },
        AssembledHandle<
            "SearchInput",
            "screen",
            {
                query: string;
                rankToken: string;
                recentAccounts: readonly {
                    fullName?: string;
                    rowKey: string;
                    userId?: string;
                    username?: string;
                }[];
                results: readonly (
                    | {
                        __typename: "unknown";
                        item: { kind: "unknown"; kindKey?: string; raw: Json };
                        key: string;
                    }
                    | {
                        __typename: "XDTTypeaheadSearchKeyword";
                        key: string;
                        keyword_lazified: {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: (...)
                                | (...);
                                id?: (...) | (...);
                                is_private?: (...) | (...) | (...);
                                is_verified?: (...) | (...) | (...);
                                latest_reel_media?: (...) | (...);
                                profile_pic_url?: (...) | (...);
                                search_serp_type?: (...) | (...);
                                username?: (...) | (...);
                            };
                        };
                    }
                    | {
                        __typename: "XDTTypeaheadSearchUser";
                        key: string;
                        rank_token?: string;
                        rankToken?: string;
                        user: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    }
                    | {
                        __typename: "XDTTypeaheadSearchHashtag";
                        hashtag: { id: string; media_count?: number; name?: string };
                        key: string;
                    }
                    | {
                        __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                        key: string;
                        keywords: readonly {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: ...;
                                id?: ...;
                                is_private?: ...;
                                is_verified?: ...;
                                latest_reel_media?: ...;
                                profile_pic_url?: ...;
                                search_serp_type?: ...;
                                username?: ...;
                            };
                        }[];
                        num_keywords_to_show?: number;
                        query_text: string;
                    }
                )[];
                session?: {
                    clientUuidRankToken: string;
                    searchSessionId: string;
                    serpSessionId?: string;
                    typeaheadSessionId: string;
                };
            },
            SearchInputActions,
            SearchInputItems,
            ScreenHandle,
            "required",
            true,
            never,
            AndroidScreens,
        >,
    >[]

    Your recent searches, shown while the field is empty.

    results: readonly ScreenListItem<
        {
            at: "results";
            by: "__typename";
            key: "key";
            source: ScreenNoItemNodes;
            variants: {
                unknown: ScreenItemDefinition<
                    "SearchInputUnknownResult",
                    {
                        __typename: "unknown";
                        item: { kind: "unknown"; kindKey?: string; raw: Json };
                        key: string;
                    },
                    {
                        __typename: "unknown";
                        item: { kind: "unknown"; kindKey?: string; raw: Json };
                        key: string;
                    },
                    Record<never, never>,
                    never,
                    never,
                    TypeaheadUnknownResultItemActions,
                    undefined,
                    never,
                    never,
                >;
                XDTTypeaheadSearchHashtag: ScreenItemDefinition<
                    "SearchInputHashtagResult",
                    {
                        __typename: "XDTTypeaheadSearchHashtag";
                        hashtag: { id: string; media_count?: number; name?: string };
                        key: string;
                    },
                    {
                        __typename: "XDTTypeaheadSearchHashtag";
                        hashtag: { id: string; media_count?: number; name?: string };
                        key: string;
                    },
                    Record<never, never>,
                    never,
                    never,
                    TypeaheadHashtagResultItemActions,
                    undefined,
                    never,
                    never,
                >;
                XDTTypeaheadSearchKeyword: ScreenItemDefinition<
                    "SearchInputKeywordResult",
                    {
                        __typename: "XDTTypeaheadSearchKeyword";
                        key: string;
                        keyword_lazified: {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: string;
                                id?: string;
                                is_private?: boolean;
                                is_verified?: boolean;
                                latest_reel_media?: number;
                                profile_pic_url?: string;
                                search_serp_type?: number;
                                username?: string;
                            };
                        };
                    },
                    {
                        __typename: "XDTTypeaheadSearchKeyword";
                        key: string;
                        keyword_lazified: {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: string;
                                id?: string;
                                is_private?: boolean;
                                is_verified?: boolean;
                                latest_reel_media?: number;
                                profile_pic_url?: string;
                                search_serp_type?: number;
                                username?: string;
                            };
                        };
                    },
                    Record<never, never>,
                    never,
                    never,
                    TypeaheadKeywordResultItemActions,
                    undefined,
                    never,
                    never,
                >;
                XDTTypeaheadSearchOverfetchedKeywords: ScreenItemDefinition<
                    "SearchInputOverfetchedKeywordsResult",
                    {
                        __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                        key: string;
                        keywords: readonly {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: (...)
                                | (...);
                                id?: (...) | (...);
                                is_private?: (...) | (...) | (...);
                                is_verified?: (...) | (...) | (...);
                                latest_reel_media?: (...) | (...);
                                profile_pic_url?: (...) | (...);
                                search_serp_type?: (...) | (...);
                                username?: (...) | (...);
                            };
                        }[];
                        num_keywords_to_show?: number;
                        query_text: string;
                    },
                    {
                        __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                        key: string;
                        keywords: readonly {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: (...)
                                | (...);
                                id?: (...) | (...);
                                is_private?: (...) | (...) | (...);
                                is_verified?: (...) | (...) | (...);
                                latest_reel_media?: (...) | (...);
                                profile_pic_url?: (...) | (...);
                                search_serp_type?: (...) | (...);
                                username?: (...) | (...);
                            };
                        }[];
                        num_keywords_to_show?: number;
                        query_text: string;
                    },
                    Record<never, never>,
                    never,
                    never,
                    TypeaheadOverfetchedKeywordsResultItemActions,
                    undefined,
                    never,
                    never,
                >;
                XDTTypeaheadSearchUser: ScreenItemDefinition<
                    "SearchInputUserResult",
                    {
                        __typename: "XDTTypeaheadSearchUser";
                        key: string;
                        rank_token?: string;
                        rankToken?: string;
                        user: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    },
                    {
                        __typename: "XDTTypeaheadSearchUser";
                        key: string;
                        rank_token?: string;
                        rankToken?: string;
                        user: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    },
                    TypeaheadUserRowState,
                    never,
                    never,
                    TypeaheadUserResultItemActions,
                    undefined,
                    never,
                    never,
                >;
            };
        },
        AssembledHandle<
            "SearchInput",
            "screen",
            {
                query: string;
                rankToken: string;
                recentAccounts: readonly {
                    fullName?: string;
                    rowKey: string;
                    userId?: string;
                    username?: string;
                }[];
                results: readonly (
                    | {
                        __typename: "unknown";
                        item: { kind: "unknown"; kindKey?: string; raw: Json };
                        key: string;
                    }
                    | {
                        __typename: "XDTTypeaheadSearchKeyword";
                        key: string;
                        keyword_lazified: {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: (...)
                                | (...);
                                id?: (...) | (...);
                                is_private?: (...) | (...) | (...);
                                is_verified?: (...) | (...) | (...);
                                latest_reel_media?: (...) | (...);
                                profile_pic_url?: (...) | (...);
                                search_serp_type?: (...) | (...);
                                username?: (...) | (...);
                            };
                        };
                    }
                    | {
                        __typename: "XDTTypeaheadSearchUser";
                        key: string;
                        rank_token?: string;
                        rankToken?: string;
                        user: {
                            full_name?: string;
                            id?: string;
                            is_private?: boolean;
                            is_verified?: boolean;
                            latest_reel_media?: number;
                            profile_pic_url?: string;
                            search_serp_type?: number;
                            username?: string;
                        };
                    }
                    | {
                        __typename: "XDTTypeaheadSearchHashtag";
                        hashtag: { id: string; media_count?: number; name?: string };
                        key: string;
                    }
                    | {
                        __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                        key: string;
                        keywords: readonly {
                            id: string;
                            name?: string;
                            user?: {
                                full_name?: ...;
                                id?: ...;
                                is_private?: ...;
                                is_verified?: ...;
                                latest_reel_media?: ...;
                                profile_pic_url?: ...;
                                search_serp_type?: ...;
                                username?: ...;
                            };
                        }[];
                        num_keywords_to_show?: number;
                        query_text: string;
                    }
                )[];
                session?: {
                    clientUuidRankToken: string;
                    searchSessionId: string;
                    serpSessionId?: string;
                    typeaheadSessionId: string;
                };
            },
            SearchInputActions,
            SearchInputItems,
            ScreenHandle,
            "required",
            true,
            never,
            AndroidScreens,
        >,
    >[]

    The results for the text in the field: keywords, accounts and hashtags, told apart by __typename.

    search: (
        ...args: readonly [string],
    ) => Effect<
        AssembledHandle<
            "SearchResultsTopTab",
            "screen",
            {
                query: string;
                session: {
                    clientUuidRankToken?: string;
                    searchSessionId: string;
                    serpSessionId: string;
                    typeaheadSessionId?: string;
                };
            },
            SearchResultsTopTabActions,
            Record<never, never>,
            ScreenHandle,
            "required",
            true,
            never,
            AndroidScreens,
        >,

            | IgApiError
            | HttpRequestError
            | ScreenEnterConcurrentError
            | ScreenDataError
            | ScreenEdgeInputError,
        never,
    >

    Taps the keyboard's search key with query: opens the Top results of the search. Answers its handle.

    tail: Effect<void, SessionFatalError>

    Waits until the background work handed over while this screen was entered has finished: a launch returns once the feed is drawn and keeps sending the rest of its requests in the process's background, and yield* feed.tail waits for them. A screen that handed over nothing — and a handle a checkpoint rebuilt, whose handed-over fibers belonged to the process that took the checkpoint — has a tail that is already complete.

    One request's ordinary failure is that request's outcome and does not fail the tail; a session-fatal answer (a checkpoint, a lost login, a suspended or disabled account) fails it with the same typed error, as it ends the process. Not waiting for it changes nothing, and interrupting the wait interrupts nothing the process runs. Inside an action or an otherwise branch (the process's screen turn) it returns at once, like the wait for the whole background.

    toJSON: () => {
        query: string;
        rankToken: string;
        recentAccounts: readonly {
            fullName?: string;
            rowKey: string;
            userId?: string;
            username?: string;
        }[];
        results: readonly (
            | {
                __typename: "unknown";
                item: { kind: "unknown"; kindKey?: string; raw: Json };
                key: string;
            }
            | {
                __typename: "XDTTypeaheadSearchKeyword";
                key: string;
                keyword_lazified: {
                    id: string;
                    name?: string;
                    user?: {
                        full_name?: string;
                        id?: string;
                        is_private?: boolean;
                        is_verified?: boolean;
                        latest_reel_media?: number;
                        profile_pic_url?: string;
                        search_serp_type?: number;
                        username?: string;
                    };
                };
            }
            | {
                __typename: "XDTTypeaheadSearchUser";
                key: string;
                rank_token?: string;
                rankToken?: string;
                user: {
                    full_name?: string;
                    id?: string;
                    is_private?: boolean;
                    is_verified?: boolean;
                    latest_reel_media?: number;
                    profile_pic_url?: string;
                    search_serp_type?: number;
                    username?: string;
                };
            }
            | {
                __typename: "XDTTypeaheadSearchHashtag";
                hashtag: { id: string; media_count?: number; name?: string };
                key: string;
            }
            | {
                __typename: "XDTTypeaheadSearchOverfetchedKeywords";
                key: string;
                keywords: readonly {
                    id: string;
                    name?: string;
                    user?: {
                        full_name?: string;
                        id?: string;
                        is_private?: boolean;
                        is_verified?: boolean;
                        latest_reel_media?: number;
                        profile_pic_url?: string;
                        search_serp_type?: number;
                        username?: string;
                    };
                }[];
                num_keywords_to_show?: number;
                query_text: string;
            }
        )[];
        session?: {
            clientUuidRankToken: string;
            searchSessionId: string;
            serpSessionId?: string;
            typeaheadSessionId: string;
        };
    }

    The handle as JSON: its data.