def METHOD_NAME(  # type: ignore[override]
    cls, _root, info: ResolveInfo, /, *, id: str
):
    user = info.context.user
    user = cast(User, user)
    manager = get_plugin_manager_promise(info.context).get()
    order = cls.get_node_or_error(
        info,
        id,
        only_type=Order,
        qs=models.Order.objects.prefetch_related("lines__variant"),
    )
    cls.check_channel_permissions(info, [order.channel_id])
    order, _ = fetch_order_prices_if_expired(order, manager)
    cls.validate_order(order)
    country = get_order_country(order)
    validate_draft_order(order, country, manager)
    with traced_atomic_transaction():
        cls.update_user_fields(order)
        order.status = OrderStatus.UNFULFILLED
        if not order.is_shipping_required():
            order.shipping_method_name = None
            order.shipping_price = zero_taxed_money(order.currency)
            if order.shipping_address:
                order.shipping_address.delete()
                order.shipping_address = None
        order.search_vector = FlatConcatSearchVector(
            *prepare_order_search_vector_value(order)
        )
        update_order_display_gross_prices(order)
        order.save()
        channel = order.channel
        order_lines_info = []
        for line in order.lines.all():
            if not line.variant:
                # we only care about stock for variants that still exist
                continue
            if line.variant.track_inventory or line.variant.is_preorder_active():
                line_data = OrderLineInfo(
                    line=line, quantity=line.quantity, variant=line.variant
                )
                order_lines_info.append(line_data)
                site = get_site_promise(info.context).get()
                try:
                    with traced_atomic_transaction():
                        allocate_stocks(
                            [line_data],
                            country,
                            channel,
                            manager,
                            check_reservations=is_reservation_enabled(
                                site.settings
                            ),
                        )
                        allocate_preorders(
                            [line_data],
                            channel.slug,
                            check_reservations=is_reservation_enabled(
                                site.settings
                            ),
                        )
                except InsufficientStock as exc:
                    errors = prepare_insufficient_stock_order_validation_errors(exc)
                    raise ValidationError({"lines": errors})
        order_info = OrderInfo(
            order=order,
            customer_email=order.get_customer_email(),
            channel=channel,
            payment=order.get_last_payment(),
            lines_data=order_lines_info,
        )
        app = get_app_promise(info.context).get()
        transaction.on_commit(
            lambda: order_created(
                order_info=order_info,
                user=user,
                app=app,
                manager=manager,
                from_draft=True,
            )
        )
    return DraftOrderComplete(order=order)