Function createMobileRuntime

createMobileRuntime<R = never>(
    layer: Layer<R | MobileRuntimeRequirements>,
    state: MobileRuntimeState,
): Promise<
    {
        account: {
            changePassword: (
                ...args: [input: ChangePasswordInput],
            ) => Promise<ChangePasswordResponse>;
            changeProfilePicture: (
                ...args: [input: ChangeProfilePictureInput],
            ) => Promise<ChangeProfilePictureResponse>;
            confirmEmail: (
                ...args: [input: { slug: string }],
            ) => Promise<AccountCommandResponse>;
            contactPointPrefill: (
                ...args: [input?: { usage?: string }],
            ) => Promise<unknown>;
            currentUser: (...args: []) => Promise<CurrentUserResponseUser>;
            editProfile: (
                ...args: [input: EditProfileInput],
            ) => Promise<CurrentUserResponse>;
            getPrefillCandidates: (...args: []) => Promise<unknown>;
            logout: (
                ...args: [input?: { oneTapAppLogin?: boolean }],
            ) => Promise<AccountLogoutResponse>;
            oneTapAppLogin: (
                ...args: [input: { nonce: string; userId: string }],
            ) => Promise<OneTapAppLoginResponse>;
            processContactPointSignals: (...args: []) => Promise<unknown>;
            recovery: {
                codeVerify: (
                    ...args: [input: RecoveryCodeVerifyInput],
                ) => Promise<RecoveryCodeVerifyResponse>;
                lookup: (
                    ...args: [input: RecoveryLookupInput],
                ) => Promise<
                    RecoveryLookupByUsernameResponse
                    | RecoveryLookupByPhoneResponse,
                >;
                lookupPhone: (
                    ...args: [input: RecoveryLookupPhoneInput],
                ) => Promise<RecoveryLookupPhoneResponse>;
                nonceLogin: (
                    ...args: [input: RecoveryNonceLoginInput],
                ) => Promise<RecoveryNonceLoginResponse>;
                sendEmail: (
                    ...args: [input: RecoverySendEmailInput],
                ) => Promise<RecoverySendEmailResponse>;
            };
            removeProfilePicture: (...args: []) => Promise<AccountCommandResponse>;
            securityInfo: (...args: []) => Promise<SecurityInfoResponse>;
            session: {
                loginActivity: (...args: []) => Promise<SessionLoginActivityResponse>;
                logout: (
                    ...args: [input: LogoutSessionInput],
                ) => Promise<LogoutSessionResponse>;
                renew: (...args: []) => Promise<OneTapAppLoginResponse>;
            };
            setBiography: (
                ...args: [input: { text: string }],
            ) => Promise<CurrentUserResponseUser>;
            setPrivate: (...args: []) => Promise<AccountCommandResponse>;
            setPublic: (...args: []) => Promise<AccountCommandResponse>;
            twoFactor: {
                bloksGetMethods: (
                    ...args: [input: TwoFactorBloksGetMethodsInput],
                ) => Promise<
                    {
                        methods: TwoFactorBloksMethod[];
                        preselectedMethod: TwoFactorBloksMethod
                        | undefined;
                        response: Bloks.BloksResponse;
                        selectQpl: TwoFactorBloksQpl | undefined;
                    },
                >;
                bloksPollTrustedNotification: (
                    ...args: [input: TwoFactorBloksPollTrustedNotificationInput],
                ) => Promise<
                    | {
                        profile?: undefined;
                        status: "denied";
                        trustedDeviceNonce?: undefined;
                    }
                    | {
                        profile: {
                            logged_in_user: {
                                full_name?: (...)
                                | (...)
                                | (...);
                                is_private?: (...) | (...) | (...) | (...);
                                is_verified?: (...) | (...) | (...) | (...);
                                pk: number;
                                pk_id: string;
                                profile_pic_url?: (...) | (...) | (...);
                                username: string;
                            };
                            status?: string;
                            trusted_device_nonce?: string;
                        };
                        status: "approved";
                        trustedDeviceNonce: string
                        | undefined;
                    }
                    | {
                        profile?: undefined;
                        status: "pending";
                        trustedDeviceNonce?: undefined;
                    },
                >;
                bloksSendWhatsAppCode: (
                    ...args: [input: TwoFactorBloksSendWhatsAppCodeInput],
                ) => Promise<{ maskedContactPoint: string | null }>;
                bloksVerifyCode: (
                    ...args: [input: TwoFactorBloksVerifyCodeInput],
                ) => Promise<
                    {
                        logged_in_user: {
                            full_name?: string
                            | null;
                            is_private?: boolean | null;
                            is_verified?: boolean | null;
                            pk: number;
                            pk_id: string;
                            profile_pic_url?: string | null;
                            username: string;
                        };
                        status?: string;
                        trusted_device_nonce?: string;
                    },
                >;
                checkTrustedNotificationStatus: (
                    ...args: [input: CheckTrustedNotificationStatusInput],
                ) => Promise<CheckTrustedNotificationStatusResponse>;
                login: (
                    ...args: [input: TwoFactorLoginInput],
                ) => Promise<TwoFactorLoginResponse>;
                sendSms: (
                    ...args: [input: SendTwoFactorLoginSmsInput],
                ) => Promise<SendTwoFactorLoginSmsResponse>;
            };
            updateBioLinks: (
                ...args: [input: UpdateBioLinksInput],
            ) => Promise<CurrentUserResponse>;
            updateProfileUsername: (
                ...args: [input: UpdateProfileUsernameInput],
            ) => Promise<UpdateProfileUsernameResponse>;
        };
        activity: {
            inbox: (...args: []) => Promise<ActivityInboxResponse>;
            newsLog: (...args: [input: NewsLogInput]) => Promise<NewsLogResponse>;
        };
        addressBook: {
            acquireOwnerContacts: (
                ...args: [input: AddressBookAcquireOwnerContactsInput],
            ) => Promise<AddressBookAcquireOwnerContactsResponse>;
            link: (
                ...args: [input: AddressBookLinkInput],
            ) => Promise<AddressBookLinkResponse>;
        };
        ads: {
            feed: {
                postsInsights: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<PostsInsightsFeedInput, {}>,
                    PostsInsightsFeedResponse,
                    PostsInsightsFeedResponseEdgesItem,
                >;
            };
            graphQL: (...args: [options: AdsGraphQLInput]) => Promise<unknown>;
            insightsAccount: (
                ...args: [options: AccountInsightsOptions],
            ) => Promise<InsightsServiceAccountResponseRootObject>;
            insightsIgtv: (...args: [mediaId: string]) => Promise<unknown>;
            insightsPost: (
                ...args: [mediaId: string],
            ) => Promise<InsightsServicePostResponseRootObject>;
        };
        clips: {
            feed: {
                home: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<ClipsHomeFeedInput, {}>,
                    ClipsHomeFeedResponseRootObject,
                    ClipsHomeFeedResponseItemsItem,
                >;
                music: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<ClipsMusicFeedInput, {}>,
                    ClipsMusicFeedResponseRootObject,
                    ClipsMusicFeedResponseItemsItem,
                >;
                user: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<ClipsUserFeedInput, {}>,
                    ClipsUserFeedResponse,
                    ClipsUserFeedResponseMedia,
                >;
            };
            writeSeenState: (
                ...args: [input: ClipsWriteSeenStateInput],
            ) => Promise<ClipsWriteSeenStateResponse>;
        };
        collections: {
            create: (
                ...args: [input: CollectionsCreateInput],
            ) => Promise<CollectionsCreateResponse>;
            feed: {
                collection: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<CollectionFeedInput, {}>,
                    CollectionsFeedResponse,
                    CollectionsFeedResponseItemsItem,
                >;
                list: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<CollectionsListFeedInput, {}>,
                    CollectionsListResponse,
                    CollectionsListResponseItemsItem,
                >;
            };
        };
        consent: {
            auto: (...args: []) => Promise<true | ConsentExistingUserFlowResponse>;
            existingUserFlow: (
                ...args: [data?: Record<string, string>],
            ) => Promise<ConsentExistingUserFlowResponse>;
            existingUserFlowDob: (
                ...args: [input: ConsentExistingUserFlowDobInput],
            ) => Promise<ConsentExistingUserFlowResponse>;
            existingUserFlowIntro: (
                ...args: [],
            ) => Promise<ConsentExistingUserFlowResponse>;
            existingUserFlowTosAndTwoAgeButton: (
                ...args: [],
            ) => Promise<ConsentExistingUserFlowResponse>;
        };
        creatives: {
            clipsAssets: (
                ...args: [input: ClipsAssetsInput],
            ) => Promise<ClipsAssetsResponse>;
            writeSupportedCapabilities: (
                ...args: [input: WriteSupportedCapabilitiesInput],
            ) => Promise<WriteSupportedCapabilitiesResponse>;
        };
        direct: {
            broadcast: (
                ...args: [input: DirectBroadcastInput],
            ) => Promise<DirectBroadcastResponse>;
            createGroupThread: (
                ...args: [input: DirectCreateGroupThreadInput],
            ) => Promise<DirectCreateGroupThreadResponse>;
            editMessage: (
                ...args: [input: DirectEditMessageInput],
            ) => Promise<StatusResponse>;
            feed: {
                inbox: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<DirectInboxFeedInput, {}>,
                    DirectInboxFeedResponse,
                    DirectInboxFeedResponseThreadsItem,
                >;
                pendingInbox: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<DirectPendingInboxFeedInput, {}>,
                    DirectInboxFeedResponse,
                    DirectInboxFeedResponseThreadsItem,
                >;
                thread: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<DirectThreadFeedInput, {}>,
                    DirectThreadFeedResponse,
                    DirectThreadFeedResponseItemsItem,
                >;
            };
            fetchAndSubscribePresence: (
                ...args: [input: DirectFetchAndSubscribePresenceInput],
            ) => Promise<DirectGetPresenceResponse>;
            getPresence: (...args: []) => Promise<DirectGetPresenceResponse>;
            getPresenceActiveNow: (...args: []) => Promise<DirectGetPresenceResponse>;
            message: {
                felixShare: (
                    input: DirectBroadcastFelixShareMessageInput,
                ) => DirectBroadcastMessage;
                forward: (
                    input: DirectBroadcastForwardMessageInput,
                ) => DirectBroadcastMessage;
                guide: (
                    input: DirectBroadcastGuideMessageInput,
                ) => DirectBroadcastMessage;
                mediaShareCarousel: (
                    input: DirectBroadcastMediaShareCarouselMessageInput,
                ) => DirectBroadcastMessage;
                mediaSharePhoto: (
                    input: DirectBroadcastMediaSharePhotoMessageInput,
                ) => DirectBroadcastMessage;
                mediaShareVideo: (
                    input: DirectBroadcastMediaShareVideoMessageInput,
                ) => DirectBroadcastMessage;
                photoAttachment: (
                    ...args: [input: DirectBroadcastPhotoAttachmentMessageInput],
                ) => Promise<{ body: { attachment_fbid: string }; item: string }>;
                profile: (
                    input: DirectBroadcastProfileMessageInput,
                ) => DirectBroadcastMessage;
                reaction: (
                    input: DirectBroadcastReactionMessageInput,
                ) => DirectBroadcastMessage;
                reelShare: (
                    input: DirectBroadcastReelShareMessageInput,
                ) => DirectBroadcastMessage;
                storyShare: (
                    input: DirectBroadcastStoryShareMessageInput,
                ) => DirectBroadcastMessage;
                text: (input: DirectBroadcastTextMessageInput) => DirectBroadcastMessage;
                videoAttachment: (
                    ...args: [input: DirectBroadcastVideoAttachmentMessageInput],
                ) => Promise<
                    {
                        body: { attachment_fbid: string; video_result: string };
                        item: string;
                    },
                >;
                voiceAttachment: (
                    ...args: [input: DirectBroadcastVoiceAttachmentMessageInput],
                ) => Promise<
                    {
                        body: {
                            attachment_fbid: string;
                            upload_id: number;
                            waveform: string;
                            waveform_sampling_frequency_hz: number;
                        };
                        item: string;
                    },
                >;
            };
            moveToFolder: (
                ...args: [input: DirectMoveToFolderInput],
            ) => Promise<StatusResponse>;
            pendingInbox: (
                ...args: [input: DirectPendingInboxInput],
            ) => Promise<DirectInboxFeedResponse>;
            quickReplyGet: (...args: []) => Promise<DirectQuickReplyGetResponse>;
            rankedRecipients: (
                ...args: [input: DirectRankedRecipientsInput],
            ) => Promise<DirectRankedRecipientsResponse>;
            searchSecondary: (
                ...args: [input: DirectSearchSecondaryInput],
            ) => Promise<DirectSearchSecondaryResponse>;
            selectableThemes: (
                ...args: [input: DirectSelectableThemesInput],
            ) => Promise<DirectSelectableThemesResponse>;
            thread: {
                addAdmins: (
                    ...args: [
                        input: { threadId: string
                        | number; userIds: (string | number)[] },
                    ],
                ) => Promise<StatusResponse>;
                addUser: (
                    ...args: [input: DirectThreadAddUserInput],
                ) => Promise<DirectThreadAddUserResponse>;
                approve: (
                    ...args: [input: { threadId: string | number }],
                ) => Promise<StatusResponse>;
                approveMultiple: (
                    ...args: [input: { threadIds: (string | number)[] }],
                ) => Promise<StatusResponse>;
                approveParticipantRequests: (
                    ...args: [input: DirectThreadApproveParticipantRequestsInput],
                ) => Promise<DirectThreadApproveParticipantRequestsResponse>;
                changeNickname: (
                    ...args: [input: DirectThreadChangeNicknameInput],
                ) => Promise<boolean>;
                decline: (
                    ...args: [input: { threadId: string | number }],
                ) => Promise<StatusResponse>;
                declineAll: (...args: []) => Promise<StatusResponse>;
                declineMultiple: (
                    ...args: [input: { threadIds: (string | number)[] }],
                ) => Promise<StatusResponse>;
                deleteItem: (
                    ...args: [input: DirectThreadDeleteItemInput],
                ) => Promise<StatusResponse>;
                getByParticipants: (
                    ...args: [input: DirectThreadGetByParticipantsInput],
                ) => Promise<DirectThreadGetByParticipantsResponse>;
                hide: (
                    ...args: [input: { threadId: string | number }],
                ) => Promise<StatusResponse>;
                leave: (
                    ...args: [input: { threadId: string | number }],
                ) => Promise<StatusResponse>;
                markItemSeen: (
                    ...args: [input: DirectThreadMarkItemSeenInput],
                ) => Promise<StatusResponse>;
                mute: (
                    ...args: [input: { threadId: string | number }],
                ) => Promise<StatusResponse>;
                removeAdmins: (
                    ...args: [
                        input: { threadId: string
                        | number; userIds: (string | number)[] },
                    ],
                ) => Promise<StatusResponse>;
                removeUsers: (
                    ...args: [
                        input: { threadId: string
                        | number; userIds: (string | number)[] },
                    ],
                ) => Promise<StatusResponse>;
                setTheme: (
                    ...args: [input: DirectThreadSetThemeInput],
                ) => Promise<DirectThreadSetThemeResponse>;
                shhScreenshot: (
                    ...args: [input: { isShhMode?: boolean; threadId: string | number }],
                ) => Promise<StatusResponse>;
                toggleShhMode: (
                    ...args: [input: { isEnabled: boolean; threadId: string | number }],
                ) => Promise<StatusResponse>;
                unmute: (
                    ...args: [input: { threadId: string | number }],
                ) => Promise<StatusResponse>;
                updateTitle: (
                    ...args: [input: DirectThreadUpdateTitleInput],
                ) => Promise<DirectThreadUpdateTitleResponse>;
            };
        };
        discover: {
            chaining: (
                ...args: [input: DiscoverChainingInput],
            ) => Promise<DiscoverChainingResponse>;
            feed: {
                discover: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<DiscoverFeedInput, {}>,
                    DiscoverFeedResponse,
                    DiscoverFeedResponseSuggestionsItem,
                >;
                topicalExplore: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        TopicalExploreFeedInput,
                        { clusterId: string; module: "explore_popular" },
                    >,
                    TopicalExploreFeedResponse,
                    TopicalExploreFeedResponseSectionalItemsItem,
                >;
            };
            profileSuBadge: (...args: []) => Promise<unknown>;
            topicalExplore: (...args: []) => Promise<unknown>;
        };
        export: () => MobileSnapshot;
        extractUserId: () => string;
        feed: <TInput, TResponse, TItem, E>(
            factory: (
                input: TInput,
            ) => Effect<
                Feed<TInput, TResponse, TItem, E, R | MobileRuntimeRequirements>,
                E,
                R | MobileRuntimeRequirements,
            >,
        ) => {
            create: (input: TInput) => PaginatedFeed<TInput, TResponse, TItem>;
        };
        friendships: {
            approve: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            besties: (...args: []) => Promise<BestiesResponse>;
            block: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            blockReel: (
                ...args: [input: FriendshipBlockReelInput],
            ) => Promise<FriendshipChangeResponse>;
            changeMutedStatus: (
                ...args: [input: ChangeMutedStatusInput],
            ) => Promise<ChangeMutedStatusResponse>;
            create: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            deny: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            destroy: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            favorite: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            favoriteForClips: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            favoriteForIgtv: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            favoriteForStories: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            feed: {
                followers: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<FollowersFeedInput, {}>,
                    FollowersFeedResponse,
                    FollowersFeedResponseUsersItem,
                >;
                following: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<FollowingFeedInput, {}>,
                    FollowingFeedResponse,
                    FollowingFeedResponseUsersItem,
                >;
                pending: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        PendingFriendshipsFeedInput,
                        { rankToken: `${string}-${string}-${string}-${string}-${string}` },
                    >,
                    PendingFriendshipsFeedResponse,
                    PendingFriendshipsFeedResponseUsersItem,
                >;
            };
            privateStoriesMembers: (
                ...args: [input: PrivateStoriesMembersInput],
            ) => Promise<PrivateStoriesMembersResponse>;
            privateStoriesSetMember: (
                ...args: [input: PrivateStoriesSetMemberInput],
            ) => Promise<{ status: string }>;
            removeFollower: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            setBesties: (
                ...args: [input: SetBestiesInput],
            ) => Promise<SetBestiesResponse>;
            show: (
                ...args: [input: FriendshipsShowInput],
            ) => Promise<FriendshipsShowResponse>;
            showMany: (
                ...args: [input: FriendshipsShowManyInput],
            ) => Promise<Record<string, FriendshipsShowResponse>>;
            unblock: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            unblockReel: (
                ...args: [input: FriendshipBlockReelInput],
            ) => Promise<FriendshipChangeResponse>;
            unfavorite: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            unfavoriteForClips: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            unfavoriteForIgtv: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
            unfavoriteForStories: (
                ...args: [input: FriendshipChangeInput],
            ) => Promise<FriendshipChangeResponse>;
        };
        graphqlWww: {
            query: (
                ...args: [form: Record<string, string>],
            ) => Promise<Bloks.BloksResponse>;
        };
        highlights: {
            createReel: (
                ...args: [input: HighlightsCreateReelInput],
            ) => Promise<HighlightsCreateReelResponse>;
            deleteReel: (
                ...args: [input: HighlightsDeleteReelInput],
            ) => Promise<HighlightsDeleteReelResponse>;
            editReel: (
                ...args: [input: HighlightsEditReelInput],
            ) => Promise<HighlightsEditReelResponse>;
            tray: (
                ...args: [input: HighlightsTrayInput],
            ) => Promise<{ tray: readonly Json[] }>;
        };
        igtv: {
            allUserSeries: (
                ...args: [input: IgtvAllUserSeriesInput],
            ) => Promise<unknown>;
            createSeries: (
                ...args: [input: IgtvCreateSeriesInput],
            ) => Promise<unknown>;
            feed: {
                browse: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<IgtvBrowseFeedInput, {}>,
                    IgtvBrowseFeedResponse,
                    IgtvBrowseFeedResponseBrowseItemsItem,
                >;
                channel: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<IgtvChannelFeedInput, {}>,
                    IgtvChannelFeedResponse,
                    IgtvChannelFeedResponseItemsItem,
                >;
            };
            search: (
                ...args: [input: IgtvSearchInput],
            ) => Promise<IgtvSearchResponse>;
            seriesAddEpisode: (
                ...args: [input: IgtvSeriesAddEpisodeInput],
            ) => Promise<unknown>;
            writeSeenState: (
                ...args: [input: IgtvWriteSeenStateInput],
            ) => Promise<IgtvWriteSeenStateResponse>;
        };
        live: {
            activateQuestion: (
                ...args: [input: { broadcastId: string; questionId: string }],
            ) => Promise<unknown>;
            addToPostLive: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveAddToPostResponse>;
            archive: (...args: []) => Promise<LiveArchiveResponse.Root>;
            comment: (
                ...args: [input: { broadcastId: string; message: string }],
            ) => Promise<unknown>;
            create: (
                ...args: [input: LiveCreateInput],
            ) => Promise<LiveCreateResponse>;
            createQuestion: (
                ...args: [input: { broadcastId: string; question: string }],
            ) => Promise<unknown>;
            deactivateQuestion: (
                ...args: [input: { broadcastId: string; questionId: string }],
            ) => Promise<unknown>;
            deletePostLive: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveAddToPostResponse>;
            endBroadcast: (
                ...args: [
                    input: { broadcastId: string; endAfterCopyrightWarning?: boolean },
                ],
            ) => Promise<unknown>;
            getCharityDonations: (
                ...args: [input: { broadcastId: string | number }],
            ) => Promise<unknown>;
            getComment: (
                ...args: [input: LiveGetCommentInput],
            ) => Promise<LiveCommentsResponse>;
            getFinalViewerList: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveFinalViewersResponse>;
            getJoinRequestCounts: (
                ...args: [input: LiveGetJoinRequestCountsInput],
            ) => Promise<LiveJoinRequestCountsResponse>;
            getLikeCount: (
                ...args: [input: { broadcastId: string; likeTs?: string | number }],
            ) => Promise<LiveLikeCountResponse>;
            getLivePresence: (...args: []) => Promise<unknown>;
            getLiveQuestions: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<unknown>;
            getQuestions: (...args: []) => Promise<LiveGetQuestionsResponse>;
            getViewerList: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveViewerListResponse>;
            heartbeatAndGetViewerCount: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveHeartbeatViewerCountResponse>;
            info: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveInfoResponse>;
            like: (
                ...args: [input: { broadcastId: string; likeCount?: number }],
            ) => Promise<LiveLikeResponse>;
            muteComment: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveSwitchCommentsResponse>;
            pinComment: (
                ...args: [input: { broadcastId: string; commentId: string }],
            ) => Promise<unknown>;
            preLiveTools: (...args: []) => Promise<unknown>;
            questions: (
                ...args: [input: { broadcastId: string | number; sources: string }],
            ) => Promise<unknown>;
            react: (...args: [input: LiveReactInput]) => Promise<LiveReactResponse>;
            resumeBroadcastAfterContentMatch: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<unknown>;
            setQuestionStatus: (
                ...args: [input: { broadcastId: string | number; status: boolean }],
            ) => Promise<unknown>;
            setSubscriptionPreference: (
                ...args: [input: { broadcastId: string; preference: string }],
            ) => Promise<unknown>;
            start: (
                ...args: [
                    input: { broadcastId: string; sendNotifications?: boolean },
                ],
            ) => Promise<LiveStartBroadcastResponse>;
            thumbnails: (
                ...args: [input: LiveThumbnailsInput],
            ) => Promise<LiveThumbnailsResponse>;
            unmuteComment: (
                ...args: [input: { broadcastId: string }],
            ) => Promise<LiveSwitchCommentsResponse>;
            unpinComment: (
                ...args: [input: { broadcastId: string; commentId: string }],
            ) => Promise<unknown>;
            wave: (
                ...args: [input: { broadcastId: string; viewerId: string }],
            ) => Promise<unknown>;
        };
        location: {
            feed: {
                media: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<LocationMediaFeedInput, {}>,
                    LocationMediaFeedResponse,
                    LocationMediaFeedResponseMedia,
                >;
            };
            info: (
                ...args: [input: { id: string | number }],
            ) => Promise<LocationInfoResponse>;
            search: (
                ...args: [input: LocationSearchInput],
            ) => Promise<LocationSearchResponse>;
            story: (
                ...args: [input: { id: string | number }],
            ) => Promise<LocationStoryResponse>;
        };
        loginNative: (
            ...args: [input: NativeLoginInput],
        ) => Promise<NativeLoginResponseLoggedInUser>;
        media: {
            addMentionedUser: (
                ...args: [input: MediaAddMentionedUserInput],
            ) => Promise<MediaAddMentionedUserResponse>;
            blocked: (...args: []) => Promise<string[]>;
            checkOffensiveComment: (
                ...args: [input: MediaCheckOffensiveCommentInput],
            ) => Promise<MediaCheckOffensiveCommentResponse>;
            comment: (
                ...args: [input: MediaCommentInput],
            ) => Promise<MediaCommentResponse>;
            commentLike: (
                ...args: [options: MediaCommentLikeOptions],
            ) => Promise<MediaCommentLikeResponse>;
            commentsBulkDelete: (
                ...args: [input: MediaCommentsBulkDeleteInput],
            ) => Promise<MediaCommentsBulkDeleteResponse>;
            commentsDisable: (
                ...args: [mediaId: string | number],
            ) => Promise<unknown>;
            commentsEnable: (...args: [mediaId: string | number]) => Promise<unknown>;
            commentUnlike: (
                ...args: [options: MediaCommentLikeOptions],
            ) => Promise<MediaCommentLikeResponse>;
            createNote: (
                ...args: [input: MediaCreateNoteInput],
            ) => Promise<MediaCreateNoteResponse>;
            delete: (...args: [input: MediaDeleteInput]) => Promise<unknown>;
            edit: (
                ...args: [input: MediaEditInput],
            ) => Promise<MediaEditResponse.Root>;
            feed: {
                archiveDayShells: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<ArchiveDayShellsFeedInput, {}>,
                    ArchiveDayShellsFeedResponse,
                    ArchiveDayShellsFeedResponseItemsItem,
                >;
                comments: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<MediaCommentsFeedInput, {}>,
                    MediaCommentsFeedResponse,
                    MediaCommentsFeedResponseCommentsItem,
                >;
                inlineChildComments: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<MediaInlineChildCommentsFeedInput, {}>,
                    MediaInlineChildCommentsFeedResponse,
                    MediaInlineChildCommentsFeedResponseChildCommentsItem,
                >;
                liked: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<LikedFeedInput, {}>,
                    LikedFeedResponse,
                    LikedFeedResponseItemsItem,
                >;
                onlyMe: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<OnlyMeFeedInput, {}>,
                    OnlyMeFeedResponse,
                    OnlyMeFeedResponseItemsItem,
                >;
                productsTagging: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        ProductsTaggingFeedInput,
                        {
                            sessionId: `${string}-${string}-${string}-${string}-${string}`;
                            waterfallId: `${string}-${string}-${string}-${string}-${string}`;
                        },
                    >,
                    ProductsTaggingFeedResponse,
                    ProductsTaggingFeedResponseComponentFeedItem,
                >;
                saved: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<SavedFeedInput, {}>,
                    SavedFeedResponse,
                    SavedFeedResponseMedia,
                >;
            };
            info: (...args: [input: MediaInfoInput]) => Promise<MediaInfoResponse>;
            like: (
                ...args: [input: MediaLikeInput],
            ) => Promise<
                | {
                    data: {
                        xig_media_like: {
                            media: {
                                __typename?: (...)
                                | (...);
                                has_liked: boolean;
                                id: string;
                                strong_id__?: (...) | (...);
                            };
                        };
                    };
                }
                | MediaLikeRestResponse,
            >;
            likers: (...args: [id: string]) => Promise<MediaLikersResponse>;
            onlyMe: (...args: [mediaId: string]) => Promise<MediaOnlyMeResponse>;
            repost: (
                ...args: [input: MediaRepostInput],
            ) => Promise<
                | { note: MediaCreateNoteResponse; repost?: undefined }
                | {
                    note: MediaCreateNoteResponse;
                    repost: {
                        data: {
                            xdt_update_media_note_repost_text: { id: string; text: string };
                        };
                    };
                },
            >;
            save: (
                ...args: [userOptions: string | MediaSaveOptions],
            ) => Promise<unknown>;
            seen: (...args: [input: MediaSeenInput]) => Promise<MediaSeenResponse>;
            storyPollVote: (
                ...args: [input: MediaStoryPollVoteInput],
            ) => Promise<MediaUpdatedMediaResponse>;
            storyQuestionResponse: (
                ...args: [input: MediaStoryQuestionResponseInput],
            ) => Promise<MediaStoryQuestionResponseResponse>;
            storyQuizAnswer: (
                ...args: [input: MediaStoryQuizAnswerInput],
            ) => Promise<MediaUpdatedMediaResponse>;
            storySliderVote: (
                ...args: [input: MediaStorySliderVoteInput],
            ) => Promise<MediaUpdatedMediaResponse>;
            undoOnlyMe: (...args: [mediaId: string]) => Promise<MediaOnlyMeResponse>;
            unlike: (
                ...args: [input: MediaImpressionInput],
            ) => Promise<MediaLikeRestResponse>;
            unsave: (...args: [mediaId: string]) => Promise<unknown>;
            updateLikeAndViewCountsVisibility: (
                ...args: [input: MediaUpdateLikeAndViewCountsVisibilityInput],
            ) => Promise<MediaUpdateLikeAndViewCountsVisibilityResponse>;
            updateNoteRepostText: (
                ...args: [input: UpdateMediaNoteRepostTextInput],
            ) => Promise<
                {
                    data: {
                        xdt_update_media_note_repost_text: { id: string; text: string };
                    };
                },
            >;
            uploadFinish: (
                ...args: [input: MediaUploadFinishInput],
            ) => Promise<unknown>;
        };
        music: {
            feed: {
                genre: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<MusicGenreFeedInput, {}>,
                    MusicGenreFeedResponse,
                    MusicGenreFeedResponseItem,
                >;
                mood: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<MusicMoodFeedInput, {}>,
                    MusicMoodFeedResponse,
                    MusicMoodFeedResponseItem,
                >;
                search: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        MusicSearchFeedInput,
                        {
                            browseSessionId: `${string}-${string}-${string}-${string}-${string}`;
                            searchSessionId: `${string}-${string}-${string}-${string}-${string}`;
                        },
                    >,
                    MusicSearchFeedResponse,
                    MusicSearchFeedResponseItem,
                >;
                trending: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<MusicTrendingFeedInput, {}>,
                    MusicTrendingFeedResponse,
                    MusicTrendingFeedResponseItem,
                >;
            };
            genres: (
                ...args: [input: MusicGenresInput],
            ) => Promise<MusicGenresResponse>;
            lyrics: (
                ...args: [input: MusicLyricsInput],
            ) => Promise<MusicLyricsResponse>;
            moods: (...args: [input: MusicMoodsInput]) => Promise<MusicMoodsResponse>;
        };
        news: { inbox: (...args: []) => Promise<NewsInboxResponse> };
        posting: {
            album: {
                photo: (
                    input: AlbumPhotoUploadInput,
                ) => {
                    metadata: () => {
                        edits: {
                            crop_center: number[];
                            crop_original_size: number[];
                            crop_zoom: number;
                        };
                        extra: { source_height: number; source_width: number };
                        internal_features: "coauthor_post" | undefined;
                        invite_coauthor_user_id: string | undefined;
                        invite_coauthor_user_ids: string[] | undefined;
                        product_tags: string | undefined;
                        source_type: string;
                        upload_id: string;
                        usertags: string | undefined;
                        xsharing_user_ids: string;
                    };
                    upload: Effect<
                        void,
                        IgApiError
                        | RequestError
                        | ParseError
                        | TransportError,
                        PlainJsonApiHttp,
                    >;
                };
                video: (
                    input: AlbumVideoUploadInput,
                ) => {
                    metadata: () => {
                        internal_features: "coauthor_post"
                        | undefined;
                        invite_coauthor_user_id: string | undefined;
                        invite_coauthor_user_ids: string[] | undefined;
                        product_tags: string | undefined;
                        source_type: string;
                        upload_id: string;
                        usertags: string | undefined;
                    };
                    upload: Effect<
                        void,
                        IgApiError
                        | RequestError
                        | ParseError
                        | TransportError,
                        PlainJsonApiHttp,
                    >;
                };
            };
            collabAccept: (
                ...args: [input: PostingCollabAcceptInput],
            ) => Promise<unknown>;
            configure: (
                ...args: [input: Record<string, unknown>],
            ) => Promise<MediaConfigureResponseRootObject>;
            products: (
                ...args: [input: ProductTagGeneratorInput],
            ) => Promise<
                {
                    tag: (
                        productId: string,
                        position: [number, number],
                    ) => PostingProductTag;
                },
            >;
            send: {
                album: (
                    ...args: [input: AlbumPostInput],
                ) => Promise<ConfigureSidecarResponse>;
                clip: (
                    ...args: [input: ClipPostInput],
                ) => Promise<MediaRepositoryConfigureToClipsResponseRootObject>;
                live: (
                    ...args: [input: PostingLiveInput],
                ) => Promise<PostingLiveConfigureSuccessResponse.Root>;
                photo: (
                    ...args: [input: TimelinePhotoPostInput],
                ) => Promise<MediaConfigureResponseRootObject>;
                story: (...args: [input: StoryPostInput]) => Promise<StoryPostResponse>;
            };
            story: {
                dm: {
                    photo: (
                        input: StoryUploaderDmPhotoInput,
                    ) => {
                        execute: () => Effect<
                            { attachment_fbid: string; upload_id: string },

                                | IgApiError
                                | RequestError
                                | ParseError
                                | TransportError
                                | MessengerMediaUploadMalformedError
                                | MessengerMediaUploadHttpError,
                            MobileHttpRequest
                            | PlainApiHeaders
                            | MessengerMediaUploadFeatures,
                        >;
                        mediaType: () => string;
                        queryString: () => | Record<string, (...) | (...) | (...) | (...)>
                        | undefined;
                        sourceType: () => string;
                        uploadId: () => string;
                    };
                    video: (
                        input: StoryUploaderDmVideoInput,
                    ) => {
                        execute: () => Effect<
                            { attachment_fbid: string },

                                | IgApiError
                                | RequestError
                                | ParseError
                                | TransportError
                                | MessengerMediaUploadMalformedError
                                | MessengerMediaUploadHttpError,
                            MobileHttpRequest
                            | PlainApiHeaders
                            | MessengerMediaUploadFeatures,
                        >;
                        mediaType: () => string;
                        queryString: () => { video: number };
                        sourceType: () => string;
                        uploadId: () => `${string}-${string}-${string}-${string}-${string}`;
                    };
                };
                tray: {
                    photo: (
                        input: StoryUploaderTrayPhotoInput,
                    ) => {
                        execute: () => Effect<
                            { upload_id: string },
                            IgApiError | RequestError | ParseError | TransportError,
                            PlainJsonApiHttp,
                        >;
                        mediaType: () => string;
                        queryString: () => | Record<string, (...) | (...) | (...) | (...)>
                        | undefined;
                        sourceType: () => string;
                        uploadId: () => string;
                    };
                    video: (
                        input: StoryUploaderTrayVideoInput,
                    ) => {
                        execute: () => Effect<
                            { upload_id: string },
                            IgApiError | RequestError | ParseError | TransportError,
                            PlainJsonApiHttp,
                        >;
                        mediaType: () => string;
                        queryString: () => { video: number };
                        sourceType: () => string;
                        uploadId: () => string;
                    };
                };
            };
        };
        restrict: {
            restrict: (
                ...args: [input: RestrictActionInput],
            ) => Promise<RestrictActionResponse>;
            unrestrict: (
                ...args: [input: RestrictActionInput],
            ) => Promise<RestrictActionResponse>;
        };
        run: <A, E>(
            effect: Effect<A, E, R | MobileRuntimeRequirements>,
        ) => Promise<A>;
        search: {
            accountSerp: (
                ...args: [input: AccountSerpInput],
            ) => Promise<AccountSerpResponse>;
            blended: (
                ...args: [input: { query: string }],
            ) => Promise<TopsearchFlatResponseListItem[]>;
            feed: {
                accountSerp: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<AccountSerpInput, {}>,
                    AccountSerpResponse,
                    AccountSerpUser,
                >;
            };
            location: (
                ...args: [
                    input: { latitude: number; longitude: number; searchQuery?: string },
                ],
            ) => Promise<LocationSearchResponseVenuesItem[]>;
            places: (
                ...args: [input: SearchPlacesInput],
            ) => Promise<SearchPlacesResponse>;
            recentSearches: (...args: []) => Promise<RecentSearchesResponse>;
            searchPlaces: (
                ...args: [input: { query: string }],
            ) => Promise<SearchPlacesResponseItem[]>;
            suggestedSearches: (
                ...args: [input: SuggestedSearchesInput],
            ) => Promise<SuggestedSearchesResponse>;
            tags: (
                ...args: [input: { query: string }],
            ) => Promise<TagsSearchResponseResultsItem[]>;
            topsearchFlat: (
                ...args: [input: TopsearchFlatInput],
            ) => Promise<TopsearchFlatResponse>;
            typeahead: (
                ...args: [input: TypeaheadSearchInput],
            ) => Promise<
                {
                    data: {
                        xdt_fbsearch__typeahead_stream: {
                            is_meta_ai_prompt_echo_enabled?: boolean
                            | null;
                            rank_token: string;
                            results: readonly (
                                | { __typename: ...; keyword_lazified: ... }
                                | { __typename: ...; rank_token?: ...; user: ... }
                                | { __typename: ...; hashtag: ... }
                            )[];
                        };
                    };
                },
            >;
            users: (
                ...args: [input: { query: string }],
            ) => Promise<UsersSearchResponseUsersItem[]>;
        };
        settings: {
            live: {
                get: (...args: []) => Promise<LiveSettingsGetResponse>;
                set: (
                    ...args: [input: LiveSettingsSetInput],
                ) => Promise<Partial<LiveSettingsGetResponse>>;
            };
            notifications: {
                change: {
                    _: (
                        ...args: [
                            contentType: NotificationSettingsContentType,
                            settingValue: string,
                        ],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<NotificationSettingsContentType>,
                    >;
                    accountSuggestions: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"connection_notification">,
                    >;
                    ads: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"ads">>;
                    announcements: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"announcements">>;
                    commentLikesAndPins: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"comment_likes">>;
                    comments: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"comments">>;
                    firstPostsAndStories: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"first_post">>;
                    followRequestAccepted: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"follow_request_accepted">,
                    >;
                    fundraisersByOthers: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"fundraiser_supporter">,
                    >;
                    groupRequest: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"direct_group_requests">,
                    >;
                    likes: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"likes">>;
                    likesAndCommentsOnPhotoUserTagged: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<
                            "like_and_comment_on_photo_user_tagged",
                        >,
                    >;
                    liveBroadcast: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"live_broadcast">>;
                    messageRequest: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"pending_direct_share">,
                    >;
                    messages: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"direct_share_activity">,
                    >;
                    muteAll: (
                        ...args: [period: NotificationSettingsMuteAllPeriod],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    newFollower: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"new_follower">>;
                    reminders: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<
                        ChangeNotificationSettingsResponse<"notification_reminders">,
                    >;
                    rooms: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"rooms">>;
                    supportRequests: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"report_updated">>;
                    taggedInBio: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"tagged_in_bio">>;
                    unrecognizedLogins: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"login_notification">>;
                    userTagged: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"user_tagged">>;
                    videoCall: (
                        ...args: [value: NotificationSettingsOptions],
                    ) => Promise<ChangeNotificationSettingsResponse<"video_call">>;
                    videoUploads: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"felix_upload_result">>;
                    videoViewCounts: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"view_count">>;
                    yourFundraisers: (
                        ...args: [value: NotificationSettingsOnOff],
                    ) => Promise<ChangeNotificationSettingsResponse<"fundraiser_creator">>;
                };
                get: {
                    _: (
                        ...args: [contentType: string],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    emailAndSms: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    followingAndFollowers: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    fromInstagram: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    fundraisers: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    instagramDirect: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    postAndComments: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    root: (...args: []) => Promise<GetNotificationSettingsResponse.Root>;
                    shopping: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                    storyLiveAndVideo: (
                        ...args: [],
                    ) => Promise<GetNotificationSettingsResponse.Root>;
                };
            };
            privacy: {
                allowTagsFrom: (
                    ...args: [input: AllowTagsFromInput],
                ) => Promise<unknown>;
                messages: {
                    get: (...args: []) => Promise<SettingsPrivacyMessagesGetResponse>;
                    set: (
                        ...args: [input: SettingsPrivacyMessagesConfig],
                    ) => Promise<
                        | SettingsPrivacyMessagesSetResponse
                        | SettingsPrivacyMessagesSetWarningAlertResponse.Root,
                    >;
                };
                tags: {
                    allowFrom: (
                        ...args: [input: AllowTagsFromInput],
                    ) => Promise<unknown>;
                    pending: {
                        feed: (
                            input: WithOptionalDefaults,
                        ) => PaginatedFeed<
                            WithOptionalDefaults<Record<string, never>, {}>,
                            PendingTagsFeedResponse.Root,
                            PendingTagsFeedResponse.Item,
                        >;
                        preference: (
                            ...args: [input: ManuallyApproveTagsInput],
                        ) => Promise<ManuallyApproveTagsResponse.Root>;
                        remove: (
                            ...args: [input: UsertagsRemoveInput],
                        ) => Promise<UsertagsRemoveResponse>;
                        review: (
                            ...args: [input: UsertagsReviewInput],
                        ) => Promise<UsertagsReviewResponse>;
                    };
                };
            };
            reel: {
                get: (...args: []) => Promise<ReelSettingsGetResponse>;
                set: (
                    ...args: [input: ReelSettingsSetInput],
                ) => Promise<Partial<ReelSettingsGetResponse>>;
            };
            security: {
                twoFactor: {
                    totp: {
                        add: (
                            ...args: [input: AddKeyTotpTwoFactorInput],
                        ) => Promise<
                            | AddKeyTotpTwoFactorResponseOk
                            | AddKeyTotpTwoFactorResponseInvalidCode,
                        >;
                        delete: (
                            ...args: [input: DeleteKeyTotpTwoFactorInput],
                        ) => Promise<DeleteKeyTotpTwoFactorResponse>;
                        disable: (...args: []) => Promise<DisableTotpTwoFactorResponse>;
                        enable: (
                            ...args: [input: EnableTwoFactorInput],
                        ) => Promise<EnableTotpTwoFactorResponse>;
                        generate: (
                            ...args: [input: GenerateTwoFactorTotpKeyInput],
                        ) => Promise<GenerateTwoFactorTotpKeyResponse>;
                        rename: (
                            ...args: [input: RenameKeyTotpTwoFactorInput],
                        ) => Promise<RenameKeyTotpTwoFactorResponse>;
                    };
                };
            };
        };
        state: MobileRuntimeState;
        status: {
            getViewableStatuses: (
                ...args: [],
            ) => Promise<GetViewableStatusesResponse>;
        };
        stories: {
            feed: {
                reelMediaViewer: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<ReelMediaViewerFeedInput, {}>,
                    ListReelMediaViewerFeedResponseRootObject,
                    ListReelMediaViewerFeedResponseUsersItem,
                >;
                reelsMedia: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<ReelsMediaFeedInput, {}>,
                    ReelsMediaFeedResponseRootObject,
                    ReelsMediaFeedResponseItem,
                >;
                reelsTray: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        ReelsTrayFeedRequestInput,
                        {
                            reason: ReelsTrayFeedReason;
                            requestId: `${string}-${string}-${string}-${string}-${string}`;
                            traySessionId: `${string}-${string}-${string}-${string}-${string}`;
                        },
                    >,
                    ReelsTrayFeedResponseRootObject,
                    ReelsTrayFeedResponseTrayItem,
                >;
                userStory: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<UserStoryFeedInput, {}>,
                    UserStoryFeedResponse,
                    UserStoryFeedResponseItemsItem,
                >;
            };
            seen: (
                ...args: [input: StoriesSeenOptions],
            ) => Promise<MediaSeenResponse>;
        };
        tags: {
            feed: {
                media: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        TagMediaFeedInput,
                        { rankToken: `${string}-${string}-${string}-${string}-${string}` },
                    >,
                    TagMediaFeedResponse,
                    TagMediaFeedResponseItemsItem,
                >;
                sections: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<TagsSectionsFeedInput, {}>,
                    TagsSectionsFeedResponse,
                    TagsSectionsFeedResponseMedia,
                >;
            };
            info: (...args: [input: TagsInfoInput]) => Promise<TagsInfoResponse>;
            search: (
                ...args: [input: TagsSearchInput],
            ) => Promise<TagsSearchResponse>;
            searchSimple: (
                ...args: [input: { q: string }],
            ) => Promise<TagsSearchResponse>;
            sections: (
                ...args: [input: TagsSectionsInput],
            ) => Promise<TagsSectionsResponse>;
            sectionSimple: (
                ...args: [input: { q: string; tab: TagsSectionsTab }],
            ) => Promise<TagsSectionsResponse>;
            story: (...args: [input: TagsStoryInput]) => Promise<TagsStoryResponse>;
        };
        timeline: {
            feed: {
                timeline: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<
                        TimelineFeedRequestInput,
                        TimelineFeedRequestInput,
                    >,
                    TimelineFeedResponse,
                    TimelineFeedResponseMediaOrAd,
                >;
            };
        };
        upload: {
            endSegmentedVideo: (
                ...args: [
                    input: {
                        ruploadParams: Record<string, string | undefined>;
                        streamId: string;
                    },
                ],
            ) => Promise<unknown>;
            initVideo: (
                ...args: [input: UploadInitVideoInput],
            ) => Promise<{ offset: number }>;
            photo: (
                ...args: [input: UploadPhotoInput],
            ) => Promise<UploadPhotoResponse>;
            startSegmentedVideo: (
                ...args: [
                    input: { ruploadParams: Record<string, string | undefined> },
                ],
            ) => Promise<UploadStartSegmentedVideoResponse>;
            video: (
                ...args: [input: UploadVideoInput],
            ) => Promise<UploadVideoResponse>;
            videoSegmentInit: (
                ...args: [input: UploadVideoSegmentInitInput],
            ) => Promise<{ offset: number }>;
            videoSegmentTransfer: (
                ...args: [input: UploadVideoSegmentTransferInput],
            ) => Promise<unknown>;
        };
        users: {
            accountDetails: (
                ...args: [input: { id?: string }],
            ) => Promise<unknown>;
            feed: {
                blocked: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<BlockedUsersFeedInput, {}>,
                    BlockedUsersFeedResponse,
                    BlockedUsersFeedResponseBlockedListItem,
                >;
                media: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<UserFeedInput, {}>,
                    UserFeedResponse,
                    UserFeedResponseItem,
                >;
                tagged: (
                    input: WithOptionalDefaults,
                ) => PaginatedFeed<
                    WithOptionalDefaults<UsertagsFeedInput, {}>,
                    UsertagsFeedResponse,
                    UsertagsFeedResponseItemsItem,
                >;
            };
            flagUser: (...args: [input: { id: string }]) => Promise<unknown>;
            formerUsernames: (...args: [input: { id?: string }]) => Promise<unknown>;
            getIdByUsername: (
                ...args: [input: { username: string }],
            ) => Promise<number>;
            info: (
                ...args: [input: { id: string }],
            ) => Promise<UsersInfoResponseUser>;
            infoStream: (...args: [input: UsersInfoStreamInput]) => Promise<any>;
            lookup: (...args: [input: UsersLookupInput]) => Promise<unknown>;
            search: (
                ...args: [input: { username: string }],
            ) => Promise<UsersSearchResponse>;
            searchExact: (
                ...args: [input: { username: string }],
            ) => Promise<UsersSearchResponseUsersItem>;
            sharedFollowerAccounts: (
                ...args: [input: { id: string }],
            ) => Promise<unknown>;
            story: (...args: [input: UsersStoryInput]) => Promise<UsersStoryResponse>;
            usernameInfo: (
                ...args: [input: { username: string }],
            ) => Promise<UsersInfoResponseUser>;
            usernameInfoStream: (
                ...args: [input: UsersUsernameInfoStreamInput],
            ) => Promise<any>;
            webProfileInfo: (
                ...args: [input: WebProfileInfoInput],
            ) => Promise<WebProfileInfoResponse>;
        };
    },
>