Interface LoginHomepageFrame

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",
                    >,

                        | 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
                        | ScreenNotOnTopError
                        | ScreenEdgeInputError
                        | RegistrationStateMissingError,
                    | MobileDevice
                    | GraphqlJsonHttp
                    | MobileApplication
                    | BloksHttp
                    | MobileNavigation
                    | ScreenCatalog
                    | ScreenStack,
                >;
            },
            Record<never, never>,
            Self,
            "required",
        >,
    >;
    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
        | ScreenNotOnTopError
        | ScreenEdgeInputError
        | LoginPendingError
        | 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,
                        >,
                        [],
                    >,
                    (
                        ...args: [],
                    ) => Effect<
                        AssembledHandle<
                            "LoginTwoFactorMethodPicker",
                            "screen",
                            {
                                offeredMethods: readonly (...)[];
                                preselected?: (...) | (...) | (...) | (...) | (...) | (...);
                                ticket: (...) & (...);
                            },
                            { chooseAuthenticationApp: (self: ..., state: ...) => ... },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                        >,

                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | ScreenNotOnTopError
                            | ScreenEdgeInputError
                            | TwoFactorTicketUnknownError,
                    >,
                >;
            },
            Record<never, never>,
            Self,
            "required",
        >,
    >;
    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",
        >,
    >;
    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,
                        >,
                        [],
                    >,
                    (
                        ...args: [],
                    ) => Effect<
                        AssembledHandle<
                            "LoginTwoFactorEnterTotpCode",
                            "screen",
                            { ticket: (...) & (...) },
                            {
                                checkApproval: (self: ..., state: ...) => ...;
                                submitCode: (self: ..., state: ...) => ...;
                            },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                        >,

                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | TwoFactorBloksIssuedIdMissingError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | ScreenNotOnTopError
                            | ScreenEdgeInputError
                            | TwoFactorTicketUnknownError,
                    >,
                >;
            },
            Record<never, never>,
            Self,
            "required",
        >,
    >;
    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],
                    >,
                    (
                        ...args: readonly [string],
                    ) => Effect<
                        AssembledHandle<
                            "AccountRecoveryAuthenticationConfirmation",
                            "screen",
                            { ticket: (...) & (...) },
                            { logInWithCode: (self: ..., state: ...) => ... },
                            Record<never, never>,
                            ScreenHandle,
                            "required",
                        >,

                            | BloksHttpError
                            | InvalidSkipOrdinalsError
                            | AccountRecoveryBloksIssuedParamsMissingError
                            | RecoverySearchClientInputParamsOrderError
                            | ScreenDataError
                            | ScreenEnterNavigationError
                            | ScreenEnterConcurrentError
                            | AccountRecoveryTicketUnknownError
                            | ScreenNotOnTopError
                            | ScreenEdgeInputError,
                    >,
                >;
            },
            Record<never, never>,
            Self,
            "required",
        >,
    >;
    recoveryTicket?: string & Brand<"RecoveryActionTicket">;
    usernameTextInputId: string;
    waterfallId: string;
}