diff --git a/src/app/Console/Command.php b/src/app/Console/Command.php
index 7c986446..6186e14d 100644
--- a/src/app/Console/Command.php
+++ b/src/app/Console/Command.php
@@ -1,267 +1,269 @@
 <?php
 
 namespace App\Console;
 
 use Illuminate\Support\Facades\DB;
 
 abstract class Command extends \Illuminate\Console\Command
 {
     /**
      * This needs to be here to be used.
      *
      * @var string
      */
     protected $commandPrefix = '';
 
     /**
      * Annotate this command as being dangerous for any potential unintended consequences.
      *
      * Commands are considered dangerous if;
      *
      * * observers are deliberately not triggered, meaning that the deletion of an object model that requires the
      *   associated observer to clean some things up, or charge a wallet or something, are deliberately not triggered,
      *
      * * deletion of objects and their relations rely on database foreign keys with obscure cascading,
      *
      * * a command will result in the permanent, irrecoverable loss of data.
      *
      * @var boolean
      */
     protected $dangerous = false;
 
 
     /**
      * Shortcut to creating a progress bar of a particular format with a particular message.
      *
      * @param int    $count   Number of progress steps
      * @param string $message The description
      *
      * @return \Symfony\Component\Console\Helper\ProgressBar
      */
     protected function createProgressBar($count, $message = null)
     {
         $bar = $this->output->createProgressBar($count);
         $bar->setFormat(
             '%current:7s%/%max:7s% [%bar%] %percent:3s%% %elapsed:7s%/%estimated:-7s% %message% '
         );
 
         if ($message) {
             $bar->setMessage("{$message}...");
         }
 
         $bar->start();
 
         return $bar;
     }
 
     /**
      * Find the domain.
      *
      * @param string $domain      Domain ID or namespace
      * @param bool   $withDeleted Include deleted
      *
      * @return \App\Domain|null
      */
     public function getDomain($domain, $withDeleted = false)
     {
         return $this->getObject(\App\Domain::class, $domain, 'namespace', $withDeleted);
     }
 
     /**
      * Find a group.
      *
      * @param string $group       Group ID or email
      * @param bool   $withDeleted Include deleted
      *
      * @return \App\Group|null
      */
     public function getGroup($group, $withDeleted = false)
     {
         return $this->getObject(\App\Group::class, $group, 'email', $withDeleted);
     }
 
     /**
      * Find an object.
      *
      * @param string      $objectClass     The name of the class
      * @param string      $objectIdOrTitle The name of a database field to match.
      * @param string|null $objectTitle     An additional database field to match.
      * @param bool        $withDeleted     Act as if --with-deleted was used
      *
      * @return mixed
      */
     public function getObject($objectClass, $objectIdOrTitle, $objectTitle = null, $withDeleted = false)
     {
         if (!$withDeleted) {
+            // @phpstan-ignore-next-line
             $withDeleted = $this->hasOption('with-deleted') && $this->option('with-deleted');
         }
 
         $object = $this->getObjectModel($objectClass, $withDeleted)->find($objectIdOrTitle);
 
         if (!$object && !empty($objectTitle)) {
             $object = $this->getObjectModel($objectClass, $withDeleted)
                 ->where($objectTitle, $objectIdOrTitle)->first();
         }
 
         return $object;
     }
 
     /**
      * Returns a preconfigured Model object for a specified class.
      *
      * @param string $objectClass The name of the class
      * @param bool   $withDeleted Include withTrashed() query
      *
      * @return mixed
      */
     protected function getObjectModel($objectClass, $withDeleted = false)
     {
         if ($withDeleted) {
             $model = $objectClass::withTrashed();
         } else {
             $model = new $objectClass();
         }
 
         if ($this->commandPrefix == 'scalpel') {
             return $model;
         }
 
         $modelsWithOwner = [
             \App\Wallet::class,
         ];
 
         $tenantId = \config('app.tenant_id');
 
         // Add tenant filter
         if (in_array(\App\Traits\BelongsToTenantTrait::class, class_uses($objectClass))) {
             $model = $model->withEnvTenantContext();
         } elseif (in_array($objectClass, $modelsWithOwner)) {
             $model = $model->whereExists(function ($query) use ($tenantId) {
                 $query->select(DB::raw(1))
                     ->from('users')
                     ->whereRaw('wallets.user_id = users.id')
                     ->whereRaw('users.tenant_id ' . ($tenantId ? "= $tenantId" : 'is null'));
             });
         }
 
         return $model;
     }
 
     /**
      * Find a resource.
      *
      * @param string $resource    Resource ID or email
      * @param bool   $withDeleted Include deleted
      *
      * @return \App\Resource|null
      */
     public function getResource($resource, $withDeleted = false)
     {
         return $this->getObject(\App\Resource::class, $resource, 'email', $withDeleted);
     }
 
     /**
      * Find a shared folder.
      *
      * @param string $folder      Folder ID or email
      * @param bool   $withDeleted Include deleted
      *
      * @return \App\SharedFolder|null
      */
     public function getSharedFolder($folder, $withDeleted = false)
     {
         return $this->getObject(\App\SharedFolder::class, $folder, 'email', $withDeleted);
     }
 
     /**
      * Find the user.
      *
      * @param string $user        User ID or email
      * @param bool   $withDeleted Include deleted
      *
      * @return \App\User|null
      */
     public function getUser($user, $withDeleted = false)
     {
         return $this->getObject(\App\User::class, $user, 'email', $withDeleted);
     }
 
     /**
      * Find the wallet.
      *
      * @param string $wallet Wallet ID
      *
      * @return \App\Wallet|null
      */
     public function getWallet($wallet)
     {
         return $this->getObject(\App\Wallet::class, $wallet, null);
     }
 
     /**
      * Execute the console command.
      *
      * @return mixed
      */
     public function handle()
     {
         if ($this->dangerous) {
             $this->warn(
                 "This command is a dangerous scalpel command with potentially significant unintended consequences"
             );
 
             $confirmation = $this->confirm("Are you sure you understand what's about to happen?");
 
             if (!$confirmation) {
                 $this->info("Better safe than sorry.");
                 return false;
             }
 
             $this->info("Vámonos!");
         }
 
         return true;
     }
 
     /**
      * Return a string for output, with any additional attributes specified as well.
      *
      * @param mixed $entry An object
      *
      * @return string
      */
     protected function toString($entry)
     {
         /**
          * Haven't figured out yet, how to test if this command implements an option for additional
          * attributes.
         if (!in_array('attr', $this->options())) {
             return $entry->{$entry->getKeyName()};
         }
         */
 
         $str = [
             $entry->{$entry->getKeyName()}
         ];
 
+        // @phpstan-ignore-next-line
         foreach ($this->option('attr') as $attr) {
             if ($attr == $entry->getKeyName()) {
                 $this->warn("Specifying {$attr} is not useful.");
                 continue;
             }
 
             if (!array_key_exists($attr, $entry->toArray())) {
                 $this->error("Attribute {$attr} isn't available");
                 continue;
             }
 
             if (is_numeric($entry->{$attr})) {
                 $str[] = $entry->{$attr};
             } else {
                 $str[] = !empty($entry->{$attr}) ? $entry->{$attr} : "null";
             }
         }
 
         return implode(" ", $str);
     }
 }
diff --git a/src/app/Console/ObjectListCommand.php b/src/app/Console/ObjectListCommand.php
index 67f64d5f..51008c8f 100644
--- a/src/app/Console/ObjectListCommand.php
+++ b/src/app/Console/ObjectListCommand.php
@@ -1,113 +1,114 @@
 <?php
 
 namespace App\Console;
 
 use Illuminate\Database\Eloquent\SoftDeletes;
 
 /**
  * This abstract class provides a means to treat objects in our model using CRUD, with the exception that
  * this particular abstract class lists objects.
  */
 abstract class ObjectListCommand extends ObjectCommand
 {
     public function __construct()
     {
         $this->description = "List all {$this->objectName} objects";
 
         $this->signature = $this->commandPrefix ? $this->commandPrefix . ":" : "";
 
         if (!empty($this->objectNamePlural)) {
             $this->signature .= "{$this->objectNamePlural}";
         } else {
             $this->signature .= "{$this->objectName}s";
         }
 
         $classes = class_uses_recursive($this->objectClass);
 
         if (in_array(SoftDeletes::class, $classes)) {
             $this->signature .= " {--with-deleted : Include deleted {$this->objectName}s}";
         }
 
         $this->signature .= " {--attr=* : Attributes other than the primary unique key to include}"
             . "{--filter=* : Additional filter(s) or a raw SQL WHERE clause}";
 
         parent::__construct();
     }
 
     /**
      * Execute the console command.
      *
      * @return mixed
      */
     public function handle()
     {
         $classes = class_uses_recursive($this->objectClass);
 
+        // @phpstan-ignore-next-line
         if (in_array(SoftDeletes::class, $classes) && $this->option('with-deleted')) {
             $objects = $this->objectClass::withTrashed();
         } else {
             $objects = new $this->objectClass();
         }
 
         foreach ($this->option('filter') as $filter) {
             $objects = $this->applyFilter($objects, $filter);
         }
 
         foreach ($objects->cursor() as $object) {
             if ($object->deleted_at) {
                 $this->info("{$this->toString($object)} (deleted at {$object->deleted_at}");
             } else {
                 $this->info("{$this->toString($object)}");
             }
         }
     }
 
     /**
      * Apply pre-configured filter or raw WHERE clause to the main query.
      *
      * @param object $query  Query builder
      * @param string $filter Pre-defined filter identifier or raw SQL WHERE clause
      *
      * @return object Query builder
      */
     public function applyFilter($query, string $filter)
     {
         // Get objects marked as deleted, i.e. --filter=TRASHED
         // Note: For use with --with-deleted option
         if (strtolower($filter) === 'trashed') {
             return $query->whereNotNull('deleted_at');
         }
 
         // Get objects with specified status, e.g. --filter=STATUS:SUSPENDED
         if (preg_match('/^status:([a-z]+)$/i', $filter, $matches)) {
             $status = strtoupper($matches[1]);
             $const = "{$this->objectClass}::STATUS_{$status}";
 
             if (defined($const)) {
                 return $query->where('status', '&', constant($const));
             }
 
             throw new \Exception("Unknown status in --filter={$filter}");
         }
 
         // Get objects older/younger than specified time, e.g. --filter=MIN-AGE:1Y
         if (preg_match('/^(min|max)-age:([0-9]+)([mdy])$/i', $filter, $matches)) {
             $operator = strtolower($matches[1]) == 'min' ? '<=' : '>=';
             $count = $matches[2];
             $period = strtolower($matches[3]);
             $date = \Carbon\Carbon::now();
 
             if ($period == 'y') {
                 $date->subYearsWithoutOverflow($count);
             } elseif ($period == 'm') {
                 $date->subMonthsWithoutOverflow($count);
             } else {
                 $date->subDays($count);
             }
 
             return $query->where('created_at', $operator, $date);
         }
 
         return $query->whereRaw($filter);
     }
 }