IGPAPI
    Preparing search index...

    Interface LoginHomepageFrame

    The login home as an edge's back returns it: its identity, the data it shows and its actions. The members are written one by one because the frame's logIn answer refers back to this frame: the per-member form keeps that recursion in a property, which the language allows, instead of a base type it would have to resolve eagerly. The action key set is pinned to the definition's own table (loginHomepageActions) below, so an action added to the definition cannot be missing from the frame.

    interface LoginHomepageFrame {
        aac: string;
        attestationChallengeNonce?: string;
        back?: ScreenBackEffect;
        createNewAccount: <Self extends ScreenHandle>(
            this: Self,
            ...args: [],
        ) => Effect<
            AssembledHandle<
                "RegistrationPhoneNumber",
                "screen",
                {},
                {
                    submitPhoneNumber: (
                        self: ScreenHandle,
                        state: State,
                    ) => (
                        ...args: [phoneNumber: string],
                    ) => Effect<
                        AssembledHandle<
                            "RegistrationConfirmationCode",
                            "screen",
                            {},
                            {
                                submitConfirmationCode: (
                                    self: ScreenHandle,
                                    state: State,
                                ) => (...args: ...) => ...;
                            },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                            true,
                        >,

                            | IgNotFoundError
                            | IgRateLimitError
                            | IgSpamError
                            | IgSignupBlockError
                            | IgCheckpointError
                            | IgAccountSuspendedError
                            | IgAccountDisabledError
                            | IgCookieConsentRequiredError
                            | IgLoginRequiredError
                            | IgUserLoggedOutError
                            | IgChallengeWrongCodeError
                            | IgPrivateUserError
                            | IgInactiveUserError
                            | IgSentryBlockError
                            | IgUploadVideoError
                            | IgConfigureVideoError
                            | IgExactUserNotFoundError
                            | IgUserIdNotFoundError
                            | IgNetworkError
                            | IgDecompressionError
                            | IgParseError
                            | IgIpBlockError
                            | IgLoginTwoFactorRequiredError
                            | IgRequestsLimitError
                            | IgNotResolvableError
                            | RequestError
                            | ParseError
                            | TransportError
                            | IgBloks429Error
                            | InvalidSkipOrdinalsError
                            | RegistrationInvalidPhoneError
                            | RegistrationChallengeRequiredError
                            | RegistrationSpamError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | ScreenEdgeInputError
                            | ScreenNotOnTopError
                            | RegistrationStateMissingError,
                        | MobileDevice
                        | GraphqlJsonHttp
                        | MobileApplication
                        | BloksHttp
                        | MobileNavigation
                        | ScreenCatalog
                        | ScreenStack,
                    >;
                },
                Record<never, never>,
                Self,
                "required",
                true,
            >,
        >;
        id: "LoginHomepage";
        kind: "screen";
        logIn: (
            ...args: [credentials: LoginInput],
        ) => Effect<
            LoginHomepageAnswer,
            | IgNotFoundError
            | IgRateLimitError
            | IgSpamError
            | IgSignupBlockError
            | IgCheckpointError
            | IgAccountSuspendedError
            | IgAccountDisabledError
            | IgCookieConsentRequiredError
            | IgLoginRequiredError
            | IgUserLoggedOutError
            | IgChallengeWrongCodeError
            | IgPrivateUserError
            | IgInactiveUserError
            | IgSentryBlockError
            | IgUploadVideoError
            | IgConfigureVideoError
            | IgExactUserNotFoundError
            | IgUserIdNotFoundError
            | IgNetworkError
            | IgDecompressionError
            | IgParseError
            | IgIpBlockError
            | IgLoginTwoFactorRequiredError
            | IgRequestsLimitError
            | IgNotResolvableError
            | RequestError
            | ParseError
            | TransportError
            | PasswordEncryptionKeysUnavailableError
            | LoginBloksParseError
            | LoginBloksRejectedError
            | LoginTwoFactorEntrypointParseError
            | LoginAccountRecoveryRequiredError
            | LoginAccountRecoveryContinueError
            | IgBloks429Error
            | IgLoginBadPasswordError
            | InvalidSkipOrdinalsError
            | AccountRecoveryBloksIssuedParamsMissingError
            | ScreenDataError
            | ScreenFeedPageError
            | ScreenEnterNavigationError
            | ScreenEnterConcurrentError
            | ScreenLaunchFirstScreenError
            | ScreenLaunchScreenNotInCatalogError
            | ScreenLaunchSplashNotOnTopError
            | ScreenLaunchSplashScreenError
            | AppAlreadyStartedError
            | ProcessNotSignedInError
            | AccountRecoveryTicketUnknownError
            | ScreenEdgeInputError
            | ScreenNotOnTopError
            | TwoFactorTicketUnknownError,
            never,
        >;
        loginEntryPoint: "login-home"
        | "landing-screen";
        oauthQpl: { instanceId: number; markerId: number };
        openApproveFromAnotherDevice: <Self extends ScreenHandle>(
            this: Self,
            ...args: [],
        ) => Effect<
            AssembledHandle<
                "LoginTwoFactorEntrypoint",
                "screen",
                { ticket: string & Brand<"TwoFactorApprovalTicket"> },
                {
                    checkApproval: (
                        self: ScreenHandle,
                        state: LoginTwoFactorApproveFromAnotherDeviceState,
                    ) => (
                        ...args: [],
                    ) => Effect<
                        LoginTwoFactorApproveFromAnotherDeviceCheck,
                        | IgNotFoundError
                        | IgRateLimitError
                        | IgSpamError
                        | IgSignupBlockError
                        | IgCheckpointError
                        | IgAccountSuspendedError
                        | IgAccountDisabledError
                        | IgCookieConsentRequiredError
                        | IgLoginRequiredError
                        | IgUserLoggedOutError
                        | IgChallengeWrongCodeError
                        | IgPrivateUserError
                        | IgInactiveUserError
                        | IgSentryBlockError
                        | IgUploadVideoError
                        | IgConfigureVideoError
                        | IgExactUserNotFoundError
                        | IgUserIdNotFoundError
                        | IgNetworkError
                        | IgDecompressionError
                        | IgParseError
                        | IgIpBlockError
                        | IgLoginTwoFactorRequiredError
                        | IgRequestsLimitError
                        | IgNotResolvableError
                        | RequestError
                        | ParseError
                        | TransportError
                        | LoginBloksParseError
                        | IgBloks429Error
                        | InvalidSkipOrdinalsError
                        | ScreenDataError
                        | ScreenFeedPageError
                        | ScreenEnterNavigationError
                        | ScreenEnterConcurrentError
                        | ScreenLaunchFirstScreenError
                        | ScreenLaunchScreenNotInCatalogError
                        | ScreenLaunchSplashNotOnTopError
                        | ScreenLaunchSplashScreenError
                        | AppAlreadyStartedError
                        | ProcessNotSignedInError
                        | ScreenNotOnTopError
                        | TwoFactorTicketUnknownError
                        | LoginTwoFactorApprovalDeclinedError,
                        | MobileSession
                        | MobileDevice
                        | MobileApplication
                        | SessionHeaderParser
                        | BloksHttp
                        | MobileNavigation
                        | ScreenStack
                        | TwoFactorTickets,
                    >;
                    tryAnotherWay: (
                        self: ScreenHandle,
                        state: LoginTwoFactorApproveFromAnotherDeviceState,
                    ) => ScreenEdgeBound<
                        ScreenEdgeShape<
                            ScreenDefinition<
                                "LoginTwoFactorMethodPicker",
                                "screen",
                                { ticket?: (...) & (...) },
                                {
                                    offeredMethods: readonly ((...) | (...) | (...) | (...) | (...))[];
                                    preselected?:
                                        | "approve_from_another_device"
                                        | "whatsapp"
                                        | "totp"
                                        | "sms"
                                        | "backup_codes";
                                    ticket: string & Brand<(...)>;
                                },
                                LoginTwoFactorChooseMethodState,
                                | BloksHttpError
                                | InvalidSkipOrdinalsError
                                | ScreenEnterNavigationError
                                | TwoFactorTicketUnknownError,
                                | MobileDevice
                                | MobileApplication
                                | BloksHttp
                                | MobileNavigation
                                | TwoFactorTickets,
                                {
                                    chooseAuthenticationApp: (
                                        self: ScreenHandle,
                                        state: LoginTwoFactorChooseMethodState,
                                    ) => ScreenEdgeBound<(...), (...)>;
                                },
                                Record<never, never>,
                                never,
                            >,
                            [],
                            "button",
                        >,
                        (
                            ...args: [],
                        ) => Effect<
                            AssembledHandle<
                                "LoginTwoFactorMethodPicker",
                                "screen",
                                {
                                    offeredMethods: readonly (...)[];
                                    preselected?: (...) | (...) | (...) | (...) | (...) | (...);
                                    ticket: (...) & (...);
                                },
                                { chooseAuthenticationApp: (self: ..., state: ...) => ... },
                                Record<never, never>,
                                ScreenHandle,
                                "required",
                                true,
                            >,

                                | BloksHttpError
                                | InvalidSkipOrdinalsError
                                | ScreenDataError
                                | ScreenEnterNavigationError
                                | ScreenEnterConcurrentError
                                | ScreenEdgeInputError
                                | ScreenNotOnTopError
                                | TwoFactorTicketUnknownError,
                            | MobileDevice
                            | MobileApplication
                            | BloksHttp
                            | MobileNavigation
                            | ScreenCatalog
                            | ScreenStack
                            | TwoFactorTickets,
                        >,
                    >;
                },
                Record<never, never>,
                Self,
                "required",
                true,
            >,
        >;
        openEmailCode: <Self extends ScreenHandle>(
            this: Self,
            ...args: [],
        ) => Effect<
            AssembledHandle<
                "AccountRecoveryEmailCode",
                "screen",
                {
                    maskedContact?: string;
                    ticket: string & Brand<"LastResortCodeEntryTicket">;
                },
                {
                    requestNewCode: (
                        self: ScreenHandle,
                        state: {
                            maskedContact?: string;
                            ticket: string & Brand<"LastResortCodeEntryTicket">;
                        },
                    ) => (
                        ...args: [],
                    ) => Effect<
                        AccountRecoveryFirstScreen
                        | undefined,

                            | IgNotFoundError
                            | IgRateLimitError
                            | IgSpamError
                            | IgSignupBlockError
                            | IgCheckpointError
                            | IgAccountSuspendedError
                            | IgAccountDisabledError
                            | IgCookieConsentRequiredError
                            | IgLoginRequiredError
                            | IgUserLoggedOutError
                            | IgChallengeWrongCodeError
                            | IgPrivateUserError
                            | IgInactiveUserError
                            | IgSentryBlockError
                            | IgUploadVideoError
                            | IgConfigureVideoError
                            | IgExactUserNotFoundError
                            | IgUserIdNotFoundError
                            | IgNetworkError
                            | IgDecompressionError
                            | IgParseError
                            | IgIpBlockError
                            | IgLoginTwoFactorRequiredError
                            | IgRequestsLimitError
                            | IgNotResolvableError
                            | RequestError
                            | ParseError
                            | TransportError
                            | LoginBloksParseError
                            | IgBloks429Error
                            | InvalidSkipOrdinalsError
                            | AccountRecoveryBloksUnknownResponseError
                            | AccountRecoveryBloksInvalidCodeError
                            | ScreenDataError
                            | ScreenFeedPageError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | ScreenLaunchFirstScreenError
                            | ScreenLaunchScreenNotInCatalogError
                            | ScreenLaunchSplashNotOnTopError
                            | ScreenLaunchSplashScreenError
                            | AppAlreadyStartedError
                            | ProcessNotSignedInError
                            | AccountRecoveryTicketUnknownError
                            | ScreenNotOnTopError,
                        | MobileSession
                        | MobileDevice
                        | MobileApplication
                        | SessionHeaderParser
                        | BloksHttp
                        | MobileNavigation
                        | AccountRecoveryTickets
                        | ScreenStack,
                    >;
                    submitCode: (
                        self: ScreenHandle,
                        state: {
                            maskedContact?: string;
                            ticket: string & Brand<"LastResortCodeEntryTicket">;
                        },
                    ) => (
                        ...args: [code: string],
                    ) => Effect<
                        AccountRecoveryFirstScreen,
                        | IgNotFoundError
                        | IgRateLimitError
                        | IgSpamError
                        | IgSignupBlockError
                        | IgCheckpointError
                        | IgAccountSuspendedError
                        | IgAccountDisabledError
                        | IgCookieConsentRequiredError
                        | IgLoginRequiredError
                        | IgUserLoggedOutError
                        | IgChallengeWrongCodeError
                        | IgPrivateUserError
                        | IgInactiveUserError
                        | IgSentryBlockError
                        | IgUploadVideoError
                        | IgConfigureVideoError
                        | IgExactUserNotFoundError
                        | IgUserIdNotFoundError
                        | IgNetworkError
                        | IgDecompressionError
                        | IgParseError
                        | IgIpBlockError
                        | IgLoginTwoFactorRequiredError
                        | IgRequestsLimitError
                        | IgNotResolvableError
                        | RequestError
                        | ParseError
                        | TransportError
                        | LoginBloksParseError
                        | IgBloks429Error
                        | InvalidSkipOrdinalsError
                        | AccountRecoveryBloksUnknownResponseError
                        | AccountRecoveryBloksInvalidCodeError
                        | ScreenDataError
                        | ScreenFeedPageError
                        | ScreenEnterNavigationError
                        | ScreenEnterConcurrentError
                        | ScreenLaunchFirstScreenError
                        | ScreenLaunchScreenNotInCatalogError
                        | ScreenLaunchSplashNotOnTopError
                        | ScreenLaunchSplashScreenError
                        | AppAlreadyStartedError
                        | ProcessNotSignedInError
                        | AccountRecoveryTicketUnknownError
                        | ScreenNotOnTopError,
                        | MobileSession
                        | MobileDevice
                        | MobileApplication
                        | SessionHeaderParser
                        | BloksHttp
                        | MobileNavigation
                        | AccountRecoveryTickets
                        | ScreenStack,
                    >;
                },
                Record<never, never>,
                Self,
                "required",
                true,
            >,
        >;
        openMethodPicker: <Self extends ScreenHandle>(
            this: Self,
            ...args: [],
        ) => Effect<
            AssembledHandle<
                "LoginTwoFactorMethodPicker",
                "screen",
                {
                    offeredMethods: readonly (
                        | "approve_from_another_device"
                        | "whatsapp"
                        | "totp"
                        | "sms"
                        | "backup_codes"
                    )[];
                    preselected?: | "approve_from_another_device"
                    | "whatsapp"
                    | "totp"
                    | "sms"
                    | "backup_codes";
                    ticket: string & Brand<"TwoFactorPickerTicket">;
                },
                {
                    chooseAuthenticationApp: (
                        self: ScreenHandle,
                        state: LoginTwoFactorChooseMethodState,
                    ) => ScreenEdgeBound<
                        ScreenEdgeShape<
                            ScreenDefinition<
                                "LoginTwoFactorEnterTotpCode",
                                "screen",
                                { ticket: string & Brand<(...)> },
                                { ticket: string & Brand<(...)> },
                                LoginTwoFactorAuthenticationAppCodeState,

                                    | BloksHttpError
                                    | InvalidSkipOrdinalsError
                                    | TwoFactorBloksIssuedIdMissingError
                                    | ScreenEnterNavigationError
                                    | TwoFactorTicketUnknownError,
                                | MobileDevice
                                | MobileApplication
                                | BloksHttp
                                | MobileNavigation
                                | TwoFactorTickets,
                                {
                                    checkApproval: (
                                        self: ScreenHandle,
                                        state: LoginTwoFactorAuthenticationAppCodeState,
                                    ) => (...args: ...) => ...;
                                    submitCode: (
                                        self: ScreenHandle,
                                        state: LoginTwoFactorAuthenticationAppCodeState,
                                    ) => (...args: ...) => ...;
                                },
                                Record<never, never>,
                                never,
                            >,
                            [],
                            "button",
                        >,
                        (
                            ...args: [],
                        ) => Effect<
                            AssembledHandle<
                                "LoginTwoFactorEnterTotpCode",
                                "screen",
                                { ticket: (...) & (...) },
                                {
                                    checkApproval: (self: ..., state: ...) => ...;
                                    submitCode: (self: ..., state: ...) => ...;
                                },
                                Record<never, never>,
                                ScreenHandle,
                                "required",
                                true,
                            >,

                                | BloksHttpError
                                | InvalidSkipOrdinalsError
                                | TwoFactorBloksIssuedIdMissingError
                                | ScreenDataError
                                | ScreenEnterNavigationError
                                | ScreenEnterConcurrentError
                                | ScreenEdgeInputError
                                | ScreenNotOnTopError
                                | TwoFactorTicketUnknownError,
                            | MobileDevice
                            | MobileApplication
                            | BloksHttp
                            | MobileNavigation
                            | ScreenCatalog
                            | ScreenStack
                            | TwoFactorTickets,
                        >,
                    >;
                },
                Record<never, never>,
                Self,
                "required",
                true,
            >,
        >;
        origin: ScreenHandle | undefined;
        passwordTextInputId: string;
        qpl: { instanceId: number; markerId: number };
        recoverPassword: <Self extends ScreenHandle>(
            this: Self,
            ...args: [],
        ) => Effect<
            AssembledHandle<
                "AccountRecoverySearch",
                "screen",
                {
                    aac: string;
                    searchScreenType: string;
                    searchTicket: string & Brand<"SearchTicket">;
                    textInputId: string;
                    waterfallId: string;
                },
                {
                    findAccount: (
                        self: ScreenHandle,
                        state: {
                            aac: string;
                            searchScreenType: string;
                            searchTicket: string & Brand<"SearchTicket">;
                            textInputId: string;
                            waterfallId: string;
                        },
                    ) => ScreenEdgeBound<
                        ScreenEdgeShape<
                            ScreenDefinition<
                                "AccountRecoveryAuthenticationConfirmation",
                                "screen",
                                { identifier: string; ticket: string & Brand<(...)> },
                                { ticket: string & Brand<(...)> },
                                { ticket: string & Brand<(...)> },

                                    | BloksHttpError
                                    | InvalidSkipOrdinalsError
                                    | AccountRecoveryBloksIssuedParamsMissingError
                                    | RecoverySearchClientInputParamsOrderError
                                    | ScreenEnterNavigationError
                                    | AccountRecoveryTicketUnknownError,
                                | MobileDevice
                                | MobileApplication
                                | BloksHttp
                                | MobileNavigation
                                | AccountRecoveryTickets,
                                {
                                    logInWithCode: (
                                        self: ScreenHandle,
                                        state: { ticket: ... },
                                    ) => (...args: ...) => ...;
                                },
                                Record<never, never>,
                                never,
                            >,
                            readonly [string],
                            "button",
                        >,
                        (
                            ...args: readonly [string],
                        ) => Effect<
                            AssembledHandle<
                                "AccountRecoveryAuthenticationConfirmation",
                                "screen",
                                { ticket: (...) & (...) },
                                { logInWithCode: (self: ..., state: ...) => ... },
                                Record<never, never>,
                                ScreenHandle,
                                "required",
                                true,
                            >,

                                | BloksHttpError
                                | InvalidSkipOrdinalsError
                                | AccountRecoveryBloksIssuedParamsMissingError
                                | RecoverySearchClientInputParamsOrderError
                                | ScreenDataError
                                | ScreenEnterNavigationError
                                | ScreenEnterConcurrentError
                                | AccountRecoveryTicketUnknownError
                                | ScreenEdgeInputError
                                | ScreenNotOnTopError,
                            | MobileDevice
                            | MobileApplication
                            | BloksHttp
                            | MobileNavigation
                            | AccountRecoveryTickets
                            | ScreenCatalog
                            | ScreenStack,
                        >,
                    >;
                },
                Record<never, never>,
                Self,
                "required",
                true,
            >,
        >;
        recoveryTicket?: string & Brand<"RecoveryActionTicket">;
        usernameTextInputId: string;
        waterfallId: string;
    }

    Hierarchy (View Summary)

    Index

    Properties

    aac attestationChallengeNonce? back? createNewAccount id kind logIn loginEntryPoint oauthQpl openApproveFromAnotherDevice openEmailCode openMethodPicker origin passwordTextInputId qpl recoverPassword recoveryTicket? usernameTextInputId waterfallId

    Properties

    aac: string
    attestationChallengeNonce?: string
    back?: ScreenBackEffect
    createNewAccount: <Self extends ScreenHandle>(
        this: Self,
        ...args: [],
    ) => Effect<
        AssembledHandle<
            "RegistrationPhoneNumber",
            "screen",
            {},
            {
                submitPhoneNumber: (
                    self: ScreenHandle,
                    state: State,
                ) => (
                    ...args: [phoneNumber: string],
                ) => Effect<
                    AssembledHandle<
                        "RegistrationConfirmationCode",
                        "screen",
                        {},
                        {
                            submitConfirmationCode: (
                                self: ScreenHandle,
                                state: State,
                            ) => (...args: ...) => ...;
                        },
                        Record<never, never>,
                        ScreenHandle,
                        "required",
                        true,
                    >,

                        | IgNotFoundError
                        | IgRateLimitError
                        | IgSpamError
                        | IgSignupBlockError
                        | IgCheckpointError
                        | IgAccountSuspendedError
                        | IgAccountDisabledError
                        | IgCookieConsentRequiredError
                        | IgLoginRequiredError
                        | IgUserLoggedOutError
                        | IgChallengeWrongCodeError
                        | IgPrivateUserError
                        | IgInactiveUserError
                        | IgSentryBlockError
                        | IgUploadVideoError
                        | IgConfigureVideoError
                        | IgExactUserNotFoundError
                        | IgUserIdNotFoundError
                        | IgNetworkError
                        | IgDecompressionError
                        | IgParseError
                        | IgIpBlockError
                        | IgLoginTwoFactorRequiredError
                        | IgRequestsLimitError
                        | IgNotResolvableError
                        | RequestError
                        | ParseError
                        | TransportError
                        | IgBloks429Error
                        | InvalidSkipOrdinalsError
                        | RegistrationInvalidPhoneError
                        | RegistrationChallengeRequiredError
                        | RegistrationSpamError
                        | ScreenDataError
                        | ScreenEnterNavigationError
                        | ScreenEnterConcurrentError
                        | ScreenEdgeInputError
                        | ScreenNotOnTopError
                        | RegistrationStateMissingError,
                    | MobileDevice
                    | GraphqlJsonHttp
                    | MobileApplication
                    | BloksHttp
                    | MobileNavigation
                    | ScreenCatalog
                    | ScreenStack,
                >;
            },
            Record<never, never>,
            Self,
            "required",
            true,
        >,
    >
    id: "LoginHomepage"
    kind: "screen"
    logIn: (
        ...args: [credentials: LoginInput],
    ) => Effect<
        LoginHomepageAnswer,
        | IgNotFoundError
        | IgRateLimitError
        | IgSpamError
        | IgSignupBlockError
        | IgCheckpointError
        | IgAccountSuspendedError
        | IgAccountDisabledError
        | IgCookieConsentRequiredError
        | IgLoginRequiredError
        | IgUserLoggedOutError
        | IgChallengeWrongCodeError
        | IgPrivateUserError
        | IgInactiveUserError
        | IgSentryBlockError
        | IgUploadVideoError
        | IgConfigureVideoError
        | IgExactUserNotFoundError
        | IgUserIdNotFoundError
        | IgNetworkError
        | IgDecompressionError
        | IgParseError
        | IgIpBlockError
        | IgLoginTwoFactorRequiredError
        | IgRequestsLimitError
        | IgNotResolvableError
        | RequestError
        | ParseError
        | TransportError
        | PasswordEncryptionKeysUnavailableError
        | LoginBloksParseError
        | LoginBloksRejectedError
        | LoginTwoFactorEntrypointParseError
        | LoginAccountRecoveryRequiredError
        | LoginAccountRecoveryContinueError
        | IgBloks429Error
        | IgLoginBadPasswordError
        | InvalidSkipOrdinalsError
        | AccountRecoveryBloksIssuedParamsMissingError
        | ScreenDataError
        | ScreenFeedPageError
        | ScreenEnterNavigationError
        | ScreenEnterConcurrentError
        | ScreenLaunchFirstScreenError
        | ScreenLaunchScreenNotInCatalogError
        | ScreenLaunchSplashNotOnTopError
        | ScreenLaunchSplashScreenError
        | AppAlreadyStartedError
        | ProcessNotSignedInError
        | AccountRecoveryTicketUnknownError
        | ScreenEdgeInputError
        | ScreenNotOnTopError
        | TwoFactorTicketUnknownError,
        never,
    >
    loginEntryPoint: "login-home" | "landing-screen"
    oauthQpl: { instanceId: number; markerId: number }
    openApproveFromAnotherDevice: <Self extends ScreenHandle>(
        this: Self,
        ...args: [],
    ) => Effect<
        AssembledHandle<
            "LoginTwoFactorEntrypoint",
            "screen",
            { ticket: string & Brand<"TwoFactorApprovalTicket"> },
            {
                checkApproval: (
                    self: ScreenHandle,
                    state: LoginTwoFactorApproveFromAnotherDeviceState,
                ) => (
                    ...args: [],
                ) => Effect<
                    LoginTwoFactorApproveFromAnotherDeviceCheck,
                    | IgNotFoundError
                    | IgRateLimitError
                    | IgSpamError
                    | IgSignupBlockError
                    | IgCheckpointError
                    | IgAccountSuspendedError
                    | IgAccountDisabledError
                    | IgCookieConsentRequiredError
                    | IgLoginRequiredError
                    | IgUserLoggedOutError
                    | IgChallengeWrongCodeError
                    | IgPrivateUserError
                    | IgInactiveUserError
                    | IgSentryBlockError
                    | IgUploadVideoError
                    | IgConfigureVideoError
                    | IgExactUserNotFoundError
                    | IgUserIdNotFoundError
                    | IgNetworkError
                    | IgDecompressionError
                    | IgParseError
                    | IgIpBlockError
                    | IgLoginTwoFactorRequiredError
                    | IgRequestsLimitError
                    | IgNotResolvableError
                    | RequestError
                    | ParseError
                    | TransportError
                    | LoginBloksParseError
                    | IgBloks429Error
                    | InvalidSkipOrdinalsError
                    | ScreenDataError
                    | ScreenFeedPageError
                    | ScreenEnterNavigationError
                    | ScreenEnterConcurrentError
                    | ScreenLaunchFirstScreenError
                    | ScreenLaunchScreenNotInCatalogError
                    | ScreenLaunchSplashNotOnTopError
                    | ScreenLaunchSplashScreenError
                    | AppAlreadyStartedError
                    | ProcessNotSignedInError
                    | ScreenNotOnTopError
                    | TwoFactorTicketUnknownError
                    | LoginTwoFactorApprovalDeclinedError,
                    | MobileSession
                    | MobileDevice
                    | MobileApplication
                    | SessionHeaderParser
                    | BloksHttp
                    | MobileNavigation
                    | ScreenStack
                    | TwoFactorTickets,
                >;
                tryAnotherWay: (
                    self: ScreenHandle,
                    state: LoginTwoFactorApproveFromAnotherDeviceState,
                ) => ScreenEdgeBound<
                    ScreenEdgeShape<
                        ScreenDefinition<
                            "LoginTwoFactorMethodPicker",
                            "screen",
                            { ticket?: (...) & (...) },
                            {
                                offeredMethods: readonly ((...) | (...) | (...) | (...) | (...))[];
                                preselected?:
                                    | "approve_from_another_device"
                                    | "whatsapp"
                                    | "totp"
                                    | "sms"
                                    | "backup_codes";
                                ticket: string & Brand<(...)>;
                            },
                            LoginTwoFactorChooseMethodState,
                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | ScreenEnterNavigationError
                            | TwoFactorTicketUnknownError,
                            | MobileDevice
                            | MobileApplication
                            | BloksHttp
                            | MobileNavigation
                            | TwoFactorTickets,
                            {
                                chooseAuthenticationApp: (
                                    self: ScreenHandle,
                                    state: LoginTwoFactorChooseMethodState,
                                ) => ScreenEdgeBound<(...), (...)>;
                            },
                            Record<never, never>,
                            never,
                        >,
                        [],
                        "button",
                    >,
                    (
                        ...args: [],
                    ) => Effect<
                        AssembledHandle<
                            "LoginTwoFactorMethodPicker",
                            "screen",
                            {
                                offeredMethods: readonly (...)[];
                                preselected?: (...) | (...) | (...) | (...) | (...) | (...);
                                ticket: (...) & (...);
                            },
                            { chooseAuthenticationApp: (self: ..., state: ...) => ... },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                            true,
                        >,

                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | ScreenEdgeInputError
                            | ScreenNotOnTopError
                            | TwoFactorTicketUnknownError,
                        | MobileDevice
                        | MobileApplication
                        | BloksHttp
                        | MobileNavigation
                        | ScreenCatalog
                        | ScreenStack
                        | TwoFactorTickets,
                    >,
                >;
            },
            Record<never, never>,
            Self,
            "required",
            true,
        >,
    >
    openEmailCode: <Self extends ScreenHandle>(
        this: Self,
        ...args: [],
    ) => Effect<
        AssembledHandle<
            "AccountRecoveryEmailCode",
            "screen",
            {
                maskedContact?: string;
                ticket: string & Brand<"LastResortCodeEntryTicket">;
            },
            {
                requestNewCode: (
                    self: ScreenHandle,
                    state: {
                        maskedContact?: string;
                        ticket: string & Brand<"LastResortCodeEntryTicket">;
                    },
                ) => (
                    ...args: [],
                ) => Effect<
                    AccountRecoveryFirstScreen
                    | undefined,

                        | IgNotFoundError
                        | IgRateLimitError
                        | IgSpamError
                        | IgSignupBlockError
                        | IgCheckpointError
                        | IgAccountSuspendedError
                        | IgAccountDisabledError
                        | IgCookieConsentRequiredError
                        | IgLoginRequiredError
                        | IgUserLoggedOutError
                        | IgChallengeWrongCodeError
                        | IgPrivateUserError
                        | IgInactiveUserError
                        | IgSentryBlockError
                        | IgUploadVideoError
                        | IgConfigureVideoError
                        | IgExactUserNotFoundError
                        | IgUserIdNotFoundError
                        | IgNetworkError
                        | IgDecompressionError
                        | IgParseError
                        | IgIpBlockError
                        | IgLoginTwoFactorRequiredError
                        | IgRequestsLimitError
                        | IgNotResolvableError
                        | RequestError
                        | ParseError
                        | TransportError
                        | LoginBloksParseError
                        | IgBloks429Error
                        | InvalidSkipOrdinalsError
                        | AccountRecoveryBloksUnknownResponseError
                        | AccountRecoveryBloksInvalidCodeError
                        | ScreenDataError
                        | ScreenFeedPageError
                        | ScreenEnterNavigationError
                        | ScreenEnterConcurrentError
                        | ScreenLaunchFirstScreenError
                        | ScreenLaunchScreenNotInCatalogError
                        | ScreenLaunchSplashNotOnTopError
                        | ScreenLaunchSplashScreenError
                        | AppAlreadyStartedError
                        | ProcessNotSignedInError
                        | AccountRecoveryTicketUnknownError
                        | ScreenNotOnTopError,
                    | MobileSession
                    | MobileDevice
                    | MobileApplication
                    | SessionHeaderParser
                    | BloksHttp
                    | MobileNavigation
                    | AccountRecoveryTickets
                    | ScreenStack,
                >;
                submitCode: (
                    self: ScreenHandle,
                    state: {
                        maskedContact?: string;
                        ticket: string & Brand<"LastResortCodeEntryTicket">;
                    },
                ) => (
                    ...args: [code: string],
                ) => Effect<
                    AccountRecoveryFirstScreen,
                    | IgNotFoundError
                    | IgRateLimitError
                    | IgSpamError
                    | IgSignupBlockError
                    | IgCheckpointError
                    | IgAccountSuspendedError
                    | IgAccountDisabledError
                    | IgCookieConsentRequiredError
                    | IgLoginRequiredError
                    | IgUserLoggedOutError
                    | IgChallengeWrongCodeError
                    | IgPrivateUserError
                    | IgInactiveUserError
                    | IgSentryBlockError
                    | IgUploadVideoError
                    | IgConfigureVideoError
                    | IgExactUserNotFoundError
                    | IgUserIdNotFoundError
                    | IgNetworkError
                    | IgDecompressionError
                    | IgParseError
                    | IgIpBlockError
                    | IgLoginTwoFactorRequiredError
                    | IgRequestsLimitError
                    | IgNotResolvableError
                    | RequestError
                    | ParseError
                    | TransportError
                    | LoginBloksParseError
                    | IgBloks429Error
                    | InvalidSkipOrdinalsError
                    | AccountRecoveryBloksUnknownResponseError
                    | AccountRecoveryBloksInvalidCodeError
                    | ScreenDataError
                    | ScreenFeedPageError
                    | ScreenEnterNavigationError
                    | ScreenEnterConcurrentError
                    | ScreenLaunchFirstScreenError
                    | ScreenLaunchScreenNotInCatalogError
                    | ScreenLaunchSplashNotOnTopError
                    | ScreenLaunchSplashScreenError
                    | AppAlreadyStartedError
                    | ProcessNotSignedInError
                    | AccountRecoveryTicketUnknownError
                    | ScreenNotOnTopError,
                    | MobileSession
                    | MobileDevice
                    | MobileApplication
                    | SessionHeaderParser
                    | BloksHttp
                    | MobileNavigation
                    | AccountRecoveryTickets
                    | ScreenStack,
                >;
            },
            Record<never, never>,
            Self,
            "required",
            true,
        >,
    >
    openMethodPicker: <Self extends ScreenHandle>(
        this: Self,
        ...args: [],
    ) => Effect<
        AssembledHandle<
            "LoginTwoFactorMethodPicker",
            "screen",
            {
                offeredMethods: readonly (
                    | "approve_from_another_device"
                    | "whatsapp"
                    | "totp"
                    | "sms"
                    | "backup_codes"
                )[];
                preselected?: | "approve_from_another_device"
                | "whatsapp"
                | "totp"
                | "sms"
                | "backup_codes";
                ticket: string & Brand<"TwoFactorPickerTicket">;
            },
            {
                chooseAuthenticationApp: (
                    self: ScreenHandle,
                    state: LoginTwoFactorChooseMethodState,
                ) => ScreenEdgeBound<
                    ScreenEdgeShape<
                        ScreenDefinition<
                            "LoginTwoFactorEnterTotpCode",
                            "screen",
                            { ticket: string & Brand<(...)> },
                            { ticket: string & Brand<(...)> },
                            LoginTwoFactorAuthenticationAppCodeState,

                                | BloksHttpError
                                | InvalidSkipOrdinalsError
                                | TwoFactorBloksIssuedIdMissingError
                                | ScreenEnterNavigationError
                                | TwoFactorTicketUnknownError,
                            | MobileDevice
                            | MobileApplication
                            | BloksHttp
                            | MobileNavigation
                            | TwoFactorTickets,
                            {
                                checkApproval: (
                                    self: ScreenHandle,
                                    state: LoginTwoFactorAuthenticationAppCodeState,
                                ) => (...args: ...) => ...;
                                submitCode: (
                                    self: ScreenHandle,
                                    state: LoginTwoFactorAuthenticationAppCodeState,
                                ) => (...args: ...) => ...;
                            },
                            Record<never, never>,
                            never,
                        >,
                        [],
                        "button",
                    >,
                    (
                        ...args: [],
                    ) => Effect<
                        AssembledHandle<
                            "LoginTwoFactorEnterTotpCode",
                            "screen",
                            { ticket: (...) & (...) },
                            {
                                checkApproval: (self: ..., state: ...) => ...;
                                submitCode: (self: ..., state: ...) => ...;
                            },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                            true,
                        >,

                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | TwoFactorBloksIssuedIdMissingError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | ScreenEdgeInputError
                            | ScreenNotOnTopError
                            | TwoFactorTicketUnknownError,
                        | MobileDevice
                        | MobileApplication
                        | BloksHttp
                        | MobileNavigation
                        | ScreenCatalog
                        | ScreenStack
                        | TwoFactorTickets,
                    >,
                >;
            },
            Record<never, never>,
            Self,
            "required",
            true,
        >,
    >
    origin: ScreenHandle | undefined
    passwordTextInputId: string
    qpl: { instanceId: number; markerId: number }
    recoverPassword: <Self extends ScreenHandle>(
        this: Self,
        ...args: [],
    ) => Effect<
        AssembledHandle<
            "AccountRecoverySearch",
            "screen",
            {
                aac: string;
                searchScreenType: string;
                searchTicket: string & Brand<"SearchTicket">;
                textInputId: string;
                waterfallId: string;
            },
            {
                findAccount: (
                    self: ScreenHandle,
                    state: {
                        aac: string;
                        searchScreenType: string;
                        searchTicket: string & Brand<"SearchTicket">;
                        textInputId: string;
                        waterfallId: string;
                    },
                ) => ScreenEdgeBound<
                    ScreenEdgeShape<
                        ScreenDefinition<
                            "AccountRecoveryAuthenticationConfirmation",
                            "screen",
                            { identifier: string; ticket: string & Brand<(...)> },
                            { ticket: string & Brand<(...)> },
                            { ticket: string & Brand<(...)> },

                                | BloksHttpError
                                | InvalidSkipOrdinalsError
                                | AccountRecoveryBloksIssuedParamsMissingError
                                | RecoverySearchClientInputParamsOrderError
                                | ScreenEnterNavigationError
                                | AccountRecoveryTicketUnknownError,
                            | MobileDevice
                            | MobileApplication
                            | BloksHttp
                            | MobileNavigation
                            | AccountRecoveryTickets,
                            {
                                logInWithCode: (
                                    self: ScreenHandle,
                                    state: { ticket: ... },
                                ) => (...args: ...) => ...;
                            },
                            Record<never, never>,
                            never,
                        >,
                        readonly [string],
                        "button",
                    >,
                    (
                        ...args: readonly [string],
                    ) => Effect<
                        AssembledHandle<
                            "AccountRecoveryAuthenticationConfirmation",
                            "screen",
                            { ticket: (...) & (...) },
                            { logInWithCode: (self: ..., state: ...) => ... },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                            true,
                        >,

                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | AccountRecoveryBloksIssuedParamsMissingError
                            | RecoverySearchClientInputParamsOrderError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | AccountRecoveryTicketUnknownError
                            | ScreenEdgeInputError
                            | ScreenNotOnTopError,
                        | MobileDevice
                        | MobileApplication
                        | BloksHttp
                        | MobileNavigation
                        | AccountRecoveryTickets
                        | ScreenCatalog
                        | ScreenStack,
                    >,
                >;
            },
            Record<never, never>,
            Self,
            "required",
            true,
        >,
    >
    recoveryTicket?: string & Brand<"RecoveryActionTicket">
    usernameTextInputId: string
    waterfallId: string

    Settings

    Member Visibility

    On This Page

    Properties