diff --git a/app/Domain/Actions/VacationRequest/CreateAction.php b/app/Domain/Actions/VacationRequest/CreateAction.php
index d3e0389a..e5a33e32 100644
--- a/app/Domain/Actions/VacationRequest/CreateAction.php
+++ b/app/Domain/Actions/VacationRequest/CreateAction.php
@@ -52,7 +52,11 @@ protected function createVacationRequest(array $data, User $creator): VacationRe
 
         $vacationRequest->save();
 
-        $days = $this->workDaysCalculator->calculateDays($vacationRequest->from, $vacationRequest->to);
+        $days = $this->workDaysCalculator->calculateDays(
+            $vacationRequest->from,
+            $vacationRequest->to,
+            $vacationRequest->type,
+        );
 
         foreach ($days as $day) {
             $vacationRequest->vacations()->create([
diff --git a/app/Domain/Enums/VacationType.php b/app/Domain/Enums/VacationType.php
index 0c377f34..0c2082d2 100644
--- a/app/Domain/Enums/VacationType.php
+++ b/app/Domain/Enums/VacationType.php
@@ -19,6 +19,7 @@ enum VacationType: string
     case Sick = "sick_vacation";
     case Absence = "absence";
     case RemoteWork = "remote_work";
+    case Delegation = "delegation";
 
     public function label(): string
     {
diff --git a/app/Domain/UnavailableDaysRetriever.php b/app/Domain/UnavailableDaysRetriever.php
new file mode 100644
index 00000000..0299e655
--- /dev/null
+++ b/app/Domain/UnavailableDaysRetriever.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Toby\Domain;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Collection;
+use Toby\Domain\Enums\VacationType;
+use Toby\Eloquent\Models\User;
+use Toby\Eloquent\Models\YearPeriod;
+
+class UnavailableDaysRetriever
+{
+    public function __construct(
+        protected UserVacationStatsRetriever $vacationStatsRetriever,
+        protected VacationTypeConfigRetriever $configRetriever,
+    ) {}
+
+    public function getUnavailableDays(User $user, YearPeriod $yearPeriod, ?VacationType $vacationType = null): Collection
+    {
+        $unavailableDays = $user->vacations()
+            ->whereBelongsTo($yearPeriod)
+            ->whereRelation(
+                "vacationRequest",
+                fn(Builder $query): Builder => $query->noStates(VacationRequestStatesRetriever::failedStates()),
+            )
+            ->pluck("date");
+
+        if (!$vacationType || !$this->configRetriever->isDuringNonWorkDays($vacationType)) {
+            $unavailableDays->push(...$yearPeriod->weekends());
+            $unavailableDays->push(...$yearPeriod->holidays()->pluck("date"));
+        }
+
+        return $unavailableDays
+            ->unique()
+            ->sort()
+            ->values();
+    }
+}
diff --git a/app/Domain/UserVacationStatsRetriever.php b/app/Domain/UserVacationStatsRetriever.php
index 775ed707..117175dc 100644
--- a/app/Domain/UserVacationStatsRetriever.php
+++ b/app/Domain/UserVacationStatsRetriever.php
@@ -70,6 +70,7 @@ public function getOtherApprovedVacationDays(User $user, YearPeriod $yearPeriod)
                 fn(Builder $query): Builder => $query
                     ->whereIn("type", $this->getNotLimitableVacationTypes())
                     ->whereNot("type", VacationType::RemoteWork)
+                    ->whereNot("type", VacationType::Delegation)
                     ->states(VacationRequestStatesRetriever::successStates()),
             )
             ->count();
diff --git a/app/Domain/VacationTypeConfigRetriever.php b/app/Domain/VacationTypeConfigRetriever.php
index 7865d413..5ee7d0d9 100644
--- a/app/Domain/VacationTypeConfigRetriever.php
+++ b/app/Domain/VacationTypeConfigRetriever.php
@@ -6,6 +6,7 @@
 
 use Illuminate\Contracts\Config\Repository;
 use Toby\Domain\Enums\EmploymentForm;
+use Toby\Domain\Enums\Role;
 use Toby\Domain\Enums\VacationType;
 
 class VacationTypeConfigRetriever
@@ -16,6 +17,8 @@ class VacationTypeConfigRetriever
     public const KEY_HAS_LIMIT = "has_limit";
     public const KEY_AVAILABLE_FOR = "available_for";
     public const KEY_IS_VACATION = "is_vacation";
+    public const KEY_DURING_NON_WORKDAYS = "during_non_workdays";
+    public const KEY_REQUEST_ALLOWED_FOR = "request_allowed_for";
 
     public function __construct(
         protected Repository $config,
@@ -46,11 +49,21 @@ public function isVacation(VacationType $type): bool
         return $this->getConfigFor($type)[static::KEY_IS_VACATION];
     }
 
+    public function isDuringNonWorkDays(VacationType $type): bool
+    {
+        return $this->getConfigFor($type)[static::KEY_DURING_NON_WORKDAYS];
+    }
+
     public function isAvailableFor(VacationType $type, EmploymentForm $employmentForm): bool
     {
         return in_array($employmentForm, $this->getConfigFor($type)[static::KEY_AVAILABLE_FOR], true);
     }
 
+    public function isRequestAllowedFor(VacationType $type, Role $role): bool
+    {
+        return in_array($role, $this->getConfigFor($type)[static::KEY_REQUEST_ALLOWED_FOR], true);
+    }
+
     protected function getConfigFor(VacationType $type): array
     {
         return $this->config->get("vacation_types.{$type->value}");
diff --git a/app/Domain/Validation/Rules/DoesNotExceedLimitRule.php b/app/Domain/Validation/Rules/DoesNotExceedLimitRule.php
index 8ce82b55..a8e2e91f 100644
--- a/app/Domain/Validation/Rules/DoesNotExceedLimitRule.php
+++ b/app/Domain/Validation/Rules/DoesNotExceedLimitRule.php
@@ -30,7 +30,7 @@ public function check(VacationRequest $vacationRequest): bool
         $limit = $this->getUserVacationLimit($vacationRequest->user, $vacationRequest->yearPeriod);
         $vacationDays = $this->getVacationDaysWithLimit($vacationRequest->user, $vacationRequest->yearPeriod);
         $estimatedDays = $this->workDaysCalculator
-            ->calculateDays($vacationRequest->from, $vacationRequest->to)
+            ->calculateDays($vacationRequest->from, $vacationRequest->to, $vacationRequest->type)
             ->count();
 
         return $limit >= ($vacationDays + $estimatedDays);
diff --git a/app/Domain/Validation/Rules/MinimumOneVacationDayRule.php b/app/Domain/Validation/Rules/MinimumOneVacationDayRule.php
index 6a38f408..a5d8c1bf 100644
--- a/app/Domain/Validation/Rules/MinimumOneVacationDayRule.php
+++ b/app/Domain/Validation/Rules/MinimumOneVacationDayRule.php
@@ -16,7 +16,7 @@ public function __construct(
     public function check(VacationRequest $vacationRequest): bool
     {
         return $this->workDaysCalculator
-            ->calculateDays($vacationRequest->from, $vacationRequest->to)
+            ->calculateDays($vacationRequest->from, $vacationRequest->to, $vacationRequest->type)
             ->isNotEmpty();
     }
 
diff --git a/app/Domain/WorkDaysCalculator.php b/app/Domain/WorkDaysCalculator.php
index 3dd3c5ff..2f77e0e9 100644
--- a/app/Domain/WorkDaysCalculator.php
+++ b/app/Domain/WorkDaysCalculator.php
@@ -7,11 +7,16 @@
 use Carbon\CarbonInterface;
 use Carbon\CarbonPeriod;
 use Illuminate\Support\Collection;
+use Toby\Domain\Enums\VacationType;
 use Toby\Eloquent\Models\YearPeriod;
 
 class WorkDaysCalculator
 {
-    public function calculateDays(CarbonInterface $from, CarbonInterface $to): Collection
+    public function __construct(
+        protected VacationTypeConfigRetriever $configRetriever,
+    ) {}
+
+    public function calculateDays(CarbonInterface $from, CarbonInterface $to, ?VacationType $vacationType = null): Collection
     {
         $period = CarbonPeriod::create($from, $to);
         $yearPeriod = YearPeriod::findByYear($from->year);
@@ -20,7 +25,7 @@ public function calculateDays(CarbonInterface $from, CarbonInterface $to): Colle
         $validDays = new Collection();
 
         foreach ($period as $day) {
-            if ($this->passes($day, $holidays)) {
+            if ($this->passes($day, $holidays, $vacationType)) {
                 $validDays->add($day);
             }
         }
@@ -28,8 +33,12 @@ public function calculateDays(CarbonInterface $from, CarbonInterface $to): Colle
         return $validDays;
     }
 
-    protected function passes(CarbonInterface $day, Collection $holidays): bool
+    protected function passes(CarbonInterface $day, Collection $holidays, ?VacationType $vacationType = null): bool
     {
+        if ($vacationType && $this->configRetriever->isDuringNonWorkDays($vacationType)) {
+            return true;
+        }
+
         if ($day->isWeekend()) {
             return false;
         }
diff --git a/app/Eloquent/Models/Vacation.php b/app/Eloquent/Models/Vacation.php
index 2dd50181..c2823201 100644
--- a/app/Eloquent/Models/Vacation.php
+++ b/app/Eloquent/Models/Vacation.php
@@ -4,6 +4,7 @@
 
 namespace Toby\Eloquent\Models;
 
+use Database\Factories\VacationFactory;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
@@ -68,4 +69,9 @@ public function scopeWhereTypes(Builder $query, Collection $types): Builder
             fn(Builder $query): Builder => $query->whereIn("type", $types),
         );
     }
+
+    protected static function newFactory(): VacationFactory
+    {
+        return VacationFactory::new();
+    }
 }
diff --git a/app/Eloquent/Models/YearPeriod.php b/app/Eloquent/Models/YearPeriod.php
index 7976fca8..386a28c3 100644
--- a/app/Eloquent/Models/YearPeriod.php
+++ b/app/Eloquent/Models/YearPeriod.php
@@ -52,6 +52,24 @@ public function holidays(): HasMany
         return $this->hasMany(Holiday::class);
     }
 
+    public function weekends(): Collection
+    {
+        $start = Carbon::create($this->year);
+        $end = Carbon::create($this->year)->endOfYear();
+
+        $weekends = new Collection();
+
+        while ($start->lessThanOrEqualTo($end)) {
+            if ($start->isWeekend()) {
+                $weekends->push($start->copy());
+            }
+
+            $start->addDay();
+        }
+
+        return $weekends;
+    }
+
     protected static function newFactory(): YearPeriodFactory
     {
         return YearPeriodFactory::new();
diff --git a/app/Infrastructure/Http/Controllers/Api/CalculateUserUnavailableDaysController.php b/app/Infrastructure/Http/Controllers/Api/CalculateUserUnavailableDaysController.php
index 5e4afe52..1da7bc2e 100644
--- a/app/Infrastructure/Http/Controllers/Api/CalculateUserUnavailableDaysController.php
+++ b/app/Infrastructure/Http/Controllers/Api/CalculateUserUnavailableDaysController.php
@@ -4,11 +4,10 @@
 
 namespace Toby\Infrastructure\Http\Controllers\Api;
 
-use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Support\Carbon;
+use Toby\Domain\UnavailableDaysRetriever;
 use Toby\Domain\UserVacationStatsRetriever;
-use Toby\Domain\VacationRequestStatesRetriever;
 use Toby\Eloquent\Helpers\YearPeriodRetriever;
 use Toby\Eloquent\Models\User;
 use Toby\Infrastructure\Http\Controllers\Controller;
@@ -20,23 +19,16 @@ public function __invoke(
         CalculateUserUnavailableDaysRequest $request,
         UserVacationStatsRetriever $vacationStatsRetriever,
         YearPeriodRetriever $yearPeriodRetriever,
+        UnavailableDaysRetriever $unavailableDaysRetriever,
     ): JsonResponse {
         /** @var User $user */
         $user = User::query()->find($request->get("user"));
         $yearPeriod = $yearPeriodRetriever->selected();
 
-        $holidays = $yearPeriod->holidays()->pluck("date");
-        $vacationDays = $user->vacations()
-            ->whereBelongsTo($yearPeriod)
-            ->whereRelation(
-                "vacationRequest",
-                fn(Builder $query): Builder => $query->noStates(VacationRequestStatesRetriever::failedStates()),
-            )
-            ->pluck("date");
+        $unavailableDays = $unavailableDaysRetriever->getUnavailableDays($user, $yearPeriod, $request->vacationType())
+            ->map(fn(Carbon $date): string => $date->toDateString())
+            ->toArray();
 
-        return new JsonResponse([
-            ...$holidays->map(fn(Carbon $date): string => $date->toDateString()),
-            ...$vacationDays->map(fn(Carbon $date): string => $date->toDateString()),
-        ]);
+        return new JsonResponse($unavailableDays);
     }
 }
diff --git a/app/Infrastructure/Http/Controllers/Api/CalculateVacationDaysController.php b/app/Infrastructure/Http/Controllers/Api/CalculateVacationDaysController.php
index be7348c8..9d84a1fd 100644
--- a/app/Infrastructure/Http/Controllers/Api/CalculateVacationDaysController.php
+++ b/app/Infrastructure/Http/Controllers/Api/CalculateVacationDaysController.php
@@ -14,7 +14,7 @@ class CalculateVacationDaysController extends Controller
 {
     public function __invoke(CalculateVacationDaysRequest $request, WorkDaysCalculator $calculator): JsonResponse
     {
-        $days = $calculator->calculateDays($request->from(), $request->to());
+        $days = $calculator->calculateDays($request->from(), $request->to(), $request->vacationType());
 
         return new JsonResponse($days->map(fn(Carbon $day): string => $day->toDateString())->all());
     }
diff --git a/app/Infrastructure/Http/Controllers/Api/GetAvailableVacationTypesController.php b/app/Infrastructure/Http/Controllers/Api/GetAvailableVacationTypesController.php
index 48a92a2a..95699f4d 100644
--- a/app/Infrastructure/Http/Controllers/Api/GetAvailableVacationTypesController.php
+++ b/app/Infrastructure/Http/Controllers/Api/GetAvailableVacationTypesController.php
@@ -22,6 +22,7 @@ public function __invoke(
 
         $types = VacationType::all()
             ->filter(fn(VacationType $type): bool => $configRetriever->isAvailableFor($type, $user->profile->employment_form))
+            ->filter(fn(VacationType $type): bool => $configRetriever->isRequestAllowedFor($type, $request->user()->role))
             ->map(fn(VacationType $type): array => [
                 "label" => $type->label(),
                 "value" => $type->value,
diff --git a/app/Infrastructure/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php b/app/Infrastructure/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php
index 03a6c9cd..dfcfdf8c 100644
--- a/app/Infrastructure/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php
+++ b/app/Infrastructure/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php
@@ -5,13 +5,23 @@
 namespace Toby\Infrastructure\Http\Requests\Api;
 
 use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rules\Enum;
+use Toby\Domain\Enums\VacationType;
 
 class CalculateUserUnavailableDaysRequest extends FormRequest
 {
     public function rules(): array
     {
         return [
+            "vacationType" => [new Enum(VacationType::class)],
             "user" => ["required", "exists:users,id"],
         ];
     }
+
+    public function vacationType(): ?VacationType
+    {
+        return $this->request->has("vacationType")
+            ? VacationType::from($this->request->get("vacationType"))
+            : null;
+    }
 }
diff --git a/app/Infrastructure/Http/Requests/Api/CalculateVacationDaysRequest.php b/app/Infrastructure/Http/Requests/Api/CalculateVacationDaysRequest.php
index 72e37dea..94ded88b 100644
--- a/app/Infrastructure/Http/Requests/Api/CalculateVacationDaysRequest.php
+++ b/app/Infrastructure/Http/Requests/Api/CalculateVacationDaysRequest.php
@@ -6,6 +6,8 @@
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Support\Carbon;
+use Illuminate\Validation\Rules\Enum;
+use Toby\Domain\Enums\VacationType;
 use Toby\Eloquent\Models\YearPeriod;
 use Toby\Infrastructure\Http\Rules\YearPeriodExists;
 
@@ -14,11 +16,17 @@ class CalculateVacationDaysRequest extends FormRequest
     public function rules(): array
     {
         return [
+            "vacationType" => ["required", new Enum(VacationType::class)],
             "from" => ["required", "date_format:Y-m-d", new YearPeriodExists()],
             "to" => ["required", "date_format:Y-m-d", new YearPeriodExists()],
         ];
     }
 
+    public function vacationType(): VacationType
+    {
+        return VacationType::from($this->request->get("vacationType"));
+    }
+
     public function from(): Carbon
     {
         return Carbon::create($this->request->get("from"));
diff --git a/config/vacation_types.php b/config/vacation_types.php
index fbd62d46..76f955a6 100644
--- a/config/vacation_types.php
+++ b/config/vacation_types.php
@@ -3,6 +3,7 @@
 declare(strict_types=1);
 
 use Toby\Domain\Enums\EmploymentForm;
+use Toby\Domain\Enums\Role;
 use Toby\Domain\Enums\VacationType;
 use Toby\Domain\VacationTypeConfigRetriever;
 
@@ -15,7 +16,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::OnRequest->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => true,
@@ -25,7 +33,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::TimeInLieu->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => false,
@@ -35,7 +50,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Sick->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => false,
@@ -45,7 +67,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Unpaid->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => true,
@@ -55,7 +84,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Special->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => true,
@@ -65,7 +101,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Childcare->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => true,
@@ -75,7 +118,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Training->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => true,
@@ -85,7 +135,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationTypeConfigRetriever::KEY_IS_VACATION => true,
     VacationType::Volunteering->value => [
@@ -96,7 +153,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Volunteering->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => true,
@@ -106,7 +170,14 @@
         VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
             EmploymentForm::EmploymentContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::Absence->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => false,
@@ -118,7 +189,14 @@
             EmploymentForm::B2bContract,
             EmploymentForm::BoardMemberContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => true,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
     ],
     VacationType::RemoteWork->value => [
         VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => false,
@@ -131,6 +209,31 @@
             EmploymentForm::B2bContract,
             EmploymentForm::BoardMemberContract,
         ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Employee,
+            Role::Administrator,
+            Role::AdministrativeApprover,
+            Role::TechnicalApprover,
+        ],
+        VacationTypeConfigRetriever::KEY_IS_VACATION => false,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => false,
+    ],
+    VacationType::Delegation->value => [
+        VacationTypeConfigRetriever::KEY_TECHNICAL_APPROVAL => false,
+        VacationTypeConfigRetriever::KEY_ADMINISTRATIVE_APPROVAL => false,
+        VacationTypeConfigRetriever::KEY_BILLABLE => true,
+        VacationTypeConfigRetriever::KEY_HAS_LIMIT => false,
+        VacationTypeConfigRetriever::KEY_AVAILABLE_FOR => [
+            EmploymentForm::EmploymentContract,
+            EmploymentForm::CommissionContract,
+            EmploymentForm::B2bContract,
+            EmploymentForm::BoardMemberContract,
+        ],
+        VacationTypeConfigRetriever::KEY_REQUEST_ALLOWED_FOR => [
+            Role::Administrator,
+            Role::AdministrativeApprover,
+        ],
         VacationTypeConfigRetriever::KEY_IS_VACATION => false,
+        VacationTypeConfigRetriever::KEY_DURING_NON_WORKDAYS => true,
     ],
 ];
diff --git a/database/factories/VacationFactory.php b/database/factories/VacationFactory.php
index d70c43d5..5afc97fb 100644
--- a/database/factories/VacationFactory.php
+++ b/database/factories/VacationFactory.php
@@ -4,12 +4,24 @@
 
 namespace Database\Factories;
 
+use Carbon\CarbonImmutable;
 use Illuminate\Database\Eloquent\Factories\Factory;
+use Toby\Eloquent\Models\User;
+use Toby\Eloquent\Models\Vacation;
+use Toby\Eloquent\Models\VacationRequest;
+use Toby\Eloquent\Models\YearPeriod;
 
 class VacationFactory extends Factory
 {
+    protected $model = Vacation::class;
+
     public function definition(): array
     {
-        return [];
+        return [
+            "user_id" => User::factory(),
+            "vacation_request_id" => VacationRequest::factory(),
+            "year_period_id" => YearPeriod::factory(),
+            "date" => CarbonImmutable::create($this->faker->dateTimeThisYear),
+        ];
     }
 }
diff --git a/database/seeders/DatabaseSeeder.php b/database/seeders/DatabaseSeeder.php
index 27618cf6..96404664 100644
--- a/database/seeders/DatabaseSeeder.php
+++ b/database/seeders/DatabaseSeeder.php
@@ -77,6 +77,7 @@ public function run(): void
                     $days = app(WorkDaysCalculator::class)->calculateDays(
                         $vacationRequest->from,
                         $vacationRequest->to,
+                        $vacationRequest->type,
                     );
 
                     foreach ($days as $day) {
diff --git a/database/seeders/DemoSeeder.php b/database/seeders/DemoSeeder.php
index f9bc4c02..7e8cb0c7 100644
--- a/database/seeders/DemoSeeder.php
+++ b/database/seeders/DemoSeeder.php
@@ -174,6 +174,7 @@ public function run(): void
                 $days = app(WorkDaysCalculator::class)->calculateDays(
                     $vacationRequest->from,
                     $vacationRequest->to,
+                    $vacationRequest->type,
                 );
 
                 foreach ($days as $day) {
@@ -243,6 +244,7 @@ public function run(): void
                 $days = app(WorkDaysCalculator::class)->calculateDays(
                     $vacationRequest->from,
                     $vacationRequest->to,
+                    $vacationRequest->type,
                 );
 
                 foreach ($days as $day) {
@@ -301,6 +303,7 @@ public function run(): void
                 $days = app(WorkDaysCalculator::class)->calculateDays(
                     $vacationRequest->from,
                     $vacationRequest->to,
+                    $vacationRequest->type,
                 );
 
                 foreach ($days as $day) {
diff --git a/lang/pl.json b/lang/pl.json
index 6e76379f..9011d187 100644
--- a/lang/pl.json
+++ b/lang/pl.json
@@ -16,6 +16,7 @@
   "sick_vacation": "Zwolnienie lekarskie",
   "absence": "Nieobecność",
   "remote_work": "Praca zdalna",
+  "delegation": "Delegacja",
   "employee": "Pracownik",
   "administrator": "Administrator",
   "technical_approver": "Techniczny akceptujący",
diff --git a/resources/js/Composables/vacationTypeInfo.js b/resources/js/Composables/vacationTypeInfo.js
index 2d643262..d2b90635 100644
--- a/resources/js/Composables/vacationTypeInfo.js
+++ b/resources/js/Composables/vacationTypeInfo.js
@@ -10,6 +10,7 @@ import MedicalBagIcon from 'vue-material-design-icons/MedicalBag.vue'
 import CalendarRemoveIcon from 'vue-material-design-icons/CalendarRemove.vue'
 import HomeCityIcon from 'vue-material-design-icons/HomeCity.vue'
 import PlusIcon from 'vue-material-design-icons/Plus.vue'
+import PlaneTrainIcon from 'vue-material-design-icons/PlaneTrain.vue'
 
 const types = [
   {
@@ -89,6 +90,13 @@ const types = [
     color: 'text-lime-500',
     border: 'border-lime-500',
   },
+  {
+    text: 'Delegacja',
+    value: 'delegation',
+    icon: PlaneTrainIcon,
+    color: 'text-sky-500',
+    border: 'border-sky-500',
+  },
   {
     text: 'Dodaj wniosek',
     value: 'create',
diff --git a/resources/js/Pages/VacationRequest/Create.vue b/resources/js/Pages/VacationRequest/Create.vue
index 8e57bd14..7a9c8271 100644
--- a/resources/js/Pages/VacationRequest/Create.vue
+++ b/resources/js/Pages/VacationRequest/Create.vue
@@ -36,7 +36,7 @@ watch(form, formData => {
   isDirty.value = formData.isDirty || from !== null || to !== null
 }, { immediate: true, deep: true })
 
-refreshEstimatedDays(form.from, form.to)
+refreshEstimatedDays(form.from, form.to, form.vacationType)
 
 const estimatedDays = ref([])
 const vacationTypes = ref([])
@@ -49,18 +49,14 @@ const stats = ref({
 
 const { minDate, maxDate } = useCurrentYearPeriodInfo()
 
-const weekends = date => (date.getDay() === 0 || date.getDay() === 6)
-
 const fromInputConfig = reactive({
   minDate,
   maxDate,
-  disable: [weekends],
 })
 
 const toInputConfig = reactive({
   minDate,
   maxDate,
-  disable: [weekends],
 })
 
 watch(() => form.user, user => {
@@ -70,6 +66,11 @@ watch(() => form.user, user => {
   refreshVacationStats(user)
 }, { immediate: true })
 
+watch(() => form.vacationType, vacationType => {
+  refreshEstimatedDays(form.from, form.to, vacationType)
+  refreshUnavailableDays(form.user, vacationType)
+})
+
 function createForm() {
   form
     .transform(data => ({
@@ -87,7 +88,7 @@ function onFromChange(selectedDates, dateStr) {
     return
   }
 
-  refreshEstimatedDays(form.from, form.to)
+  refreshEstimatedDays(form.from, form.to, form.vacationType)
 }
 
 function onToChange(selectedDates, dateStr) {
@@ -96,7 +97,7 @@ function onToChange(selectedDates, dateStr) {
 
     return
   }
-  refreshEstimatedDays(form.from, form.to)
+  refreshEstimatedDays(form.from, form.to, form.vacationType)
 }
 
 function resetForm() {
@@ -106,12 +107,15 @@ function resetForm() {
 }
 
 function checkUserId(userId) {
-  return userId > 0 ? userId: null
+  return userId > 0 ? userId : null
 }
 
-async function refreshEstimatedDays(from, to) {
-  if (from && to) {
-    const res = await axios.post('/api/vacation/calculate-days', { from, to })
+async function refreshEstimatedDays(from, to, vacationType) {
+  if (from && to && vacationType) {
+    const res = await axios.post(
+      '/api/vacation/calculate-days',
+      { vacationType: vacationType.value, from: from, to: to },
+    )
 
     estimatedDays.value = res.data
   }
@@ -124,18 +128,15 @@ async function refreshVacationStats(user) {
 }
 
 async function refreshUnavailableDays(user) {
-  const res = await axios.post('/api/vacation/calculate-unavailable-days', { user: user.id })
+  const res = await axios.post(
+    '/api/vacation/calculate-unavailable-days',
+    { user: user.id, vacationType: form.vacationType?.value },
+  )
   const unavailableDays = res.data
 
-  fromInputConfig.disable = [
-    weekends,
-    ...unavailableDays,
-  ]
+  fromInputConfig.disable = unavailableDays
 
-  toInputConfig.disable = [
-    weekends,
-    ...unavailableDays,
-  ]
+  toInputConfig.disable = unavailableDays
 }
 
 async function refreshAvailableTypes(user) {
@@ -150,7 +151,9 @@ async function refreshAvailableTypes(user) {
 
 <template>
   <InertiaHead title="Dodaj wniosek" />
-  <div :class="[stats.limit > 0 ? ' grid grid-cols-1 gap-4 items-start xl:grid-cols-3 xl:gap-8' : 'mx-auto w-full max-w-7xl']">
+  <div
+    :class="[stats.limit > 0 ? ' grid grid-cols-1 gap-4 items-start xl:grid-cols-3 xl:gap-8' : 'mx-auto w-full max-w-7xl']"
+  >
     <div class="flex flex-col h-full bg-white shadow-md xl:col-span-2">
       <div class="p-4 sm:px-6">
         <h2 class="text-lg font-medium leading-6 text-gray-900">
@@ -308,7 +311,9 @@ async function refreshAvailableTypes(user) {
                   leave-from-class="opacity-100"
                   leave-to-class="opacity-0"
                 >
-                  <ListboxOptions class="overflow-auto absolute z-10 py-1 mt-1 w-full max-w-lg max-h-60 text-base bg-white rounded-md focus:outline-none ring-1 ring-black ring-opacity-5 shadow-lg sm:text-sm">
+                  <ListboxOptions
+                    class="overflow-auto absolute z-10 py-1 mt-1 w-full max-w-lg max-h-60 text-base bg-white rounded-md focus:outline-none ring-1 ring-black ring-opacity-5 shadow-lg sm:text-sm"
+                  >
                     <ListboxOption
                       v-for="vacationType in vacationTypes"
                       :key="vacationType.value"
diff --git a/tests/Feature/VacationRequestTest.php b/tests/Feature/VacationRequestTest.php
index 2c7d0f12..2b364748 100644
--- a/tests/Feature/VacationRequestTest.php
+++ b/tests/Feature/VacationRequestTest.php
@@ -304,6 +304,38 @@ public function testUserCannotCreateVacationRequestAtWeekend(): void
             ]);
     }
 
+    public function testUserCanCreateNonWorkDayVacationRequestAtWeekend(): void
+    {
+        $user = User::factory()->create();
+        $currentYearPeriod = YearPeriod::current();
+
+        VacationLimit::factory([
+            "days" => 20,
+        ])
+            ->for($user)
+            ->for($currentYearPeriod)
+            ->create();
+
+        $this->actingAs($user)
+            ->post("/vacation/requests", [
+                "user" => $user->id,
+                "type" => VacationType::Delegation->value,
+                "from" => Carbon::create($currentYearPeriod->year, 2, 5)->toDateString(),
+                "to" => Carbon::create($currentYearPeriod->year, 2, 6)->toDateString(),
+                "comment" => "Delegation at weekend.",
+            ])
+            ->assertRedirect();
+
+        $this->assertDatabaseHas("vacation_requests", [
+            "user_id" => $user->id,
+            "year_period_id" => $currentYearPeriod->id,
+            "type" => VacationType::Delegation->value,
+            "from" => Carbon::create($currentYearPeriod->year, 2, 5)->toDateString(),
+            "to" => Carbon::create($currentYearPeriod->year, 2, 6)->toDateString(),
+            "comment" => "Delegation at weekend.",
+        ]);
+    }
+
     public function testUserCannotCreateVacationRequestAtHoliday(): void
     {
         $user = User::factory()->create();
@@ -336,6 +368,45 @@ public function testUserCannotCreateVacationRequestAtHoliday(): void
             ]);
     }
 
+    public function testUserCanCreateNonWorkDayVacationAtHoliday(): void
+    {
+        $user = User::factory()->create();
+        $currentYearPeriod = YearPeriod::current();
+
+        VacationLimit::factory([
+            "days" => 20,
+        ])
+            ->for($user)
+            ->for($currentYearPeriod)
+            ->create();
+
+        foreach ($this->polishHolidaysRetriever->getForYearPeriod($currentYearPeriod) as $holiday) {
+            $currentYearPeriod->holidays()->create([
+                "name" => $holiday["name"],
+                "date" => $holiday["date"],
+            ]);
+        }
+
+        $this->actingAs($user)
+            ->post("/vacation/requests", [
+                "user" => $user->id,
+                "type" => VacationType::Delegation->value,
+                "from" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+                "to" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+                "comment" => "Delegation at holiday.",
+            ])
+            ->assertRedirect();
+
+        $this->assertDatabaseHas("vacation_requests", [
+            "user_id" => $user->id,
+            "year_period_id" => $currentYearPeriod->id,
+            "type" => VacationType::Delegation->value,
+            "from" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+            "to" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+            "comment" => "Delegation at holiday.",
+        ]);
+    }
+
     public function testUserCannotCreateVacationRequestIfHeHasPendingVacationRequestInThisRange(): void
     {
         $user = User::factory()
@@ -636,4 +707,160 @@ public function testEmployeeCannotDownloadAnotherEmployeesVacationRequestAsPdf()
             ->get("/vacation/requests/{$vacationRequest->id}/download")
             ->assertForbidden();
     }
+
+    public function testCorrectVacationTypesAreAvailableForEmployee(): void
+    {
+        $employee = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
+            ->create();
+
+        $this->actingAs($employee)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $employee->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Urlop wypoczynkowy", "value" => "vacation"],
+                ["label" => "Urlop na żądanie", "value" => "vacation_on_request"],
+                ["label" => "Urlop okolicznościowy", "value" => "special_vacation"],
+                ["label" => "Opieka nad dzieckiem (art. 188 kp)", "value" => "childcare_vacation"],
+                ["label" => "Urlop szkoleniowy", "value" => "training_vacation"],
+                ["label" => "Urlop bezpłatny", "value" => "unpaid_vacation"],
+                ["label" => "Wolontariat", "value" => "volunteering_vacation"],
+                ["label" => "Odbiór za święto", "value" => "time_in_lieu"],
+                ["label" => "Zwolnienie lekarskie", "value" => "sick_vacation"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+            ]);
+    }
+
+    public function testCorrectVacationTypesAreAvailableForTechnicalApprover(): void
+    {
+        $technicalApprover = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
+            ->technicalApprover()
+            ->create();
+
+        $this->actingAs($technicalApprover)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $technicalApprover->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Urlop wypoczynkowy", "value" => "vacation"],
+                ["label" => "Urlop na żądanie", "value" => "vacation_on_request"],
+                ["label" => "Urlop okolicznościowy", "value" => "special_vacation"],
+                ["label" => "Opieka nad dzieckiem (art. 188 kp)", "value" => "childcare_vacation"],
+                ["label" => "Urlop szkoleniowy", "value" => "training_vacation"],
+                ["label" => "Urlop bezpłatny", "value" => "unpaid_vacation"],
+                ["label" => "Wolontariat", "value" => "volunteering_vacation"],
+                ["label" => "Odbiór za święto", "value" => "time_in_lieu"],
+                ["label" => "Zwolnienie lekarskie", "value" => "sick_vacation"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+            ]);
+    }
+
+    public function testCorrectVacationTypesAreAvailableForAdministrativeApprover(): void
+    {
+        $administrativeApprover = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
+            ->administrativeApprover()
+            ->create();
+
+        $this->actingAs($administrativeApprover)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $administrativeApprover->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Urlop wypoczynkowy", "value" => "vacation"],
+                ["label" => "Urlop na żądanie", "value" => "vacation_on_request"],
+                ["label" => "Urlop okolicznościowy", "value" => "special_vacation"],
+                ["label" => "Opieka nad dzieckiem (art. 188 kp)", "value" => "childcare_vacation"],
+                ["label" => "Urlop szkoleniowy", "value" => "training_vacation"],
+                ["label" => "Urlop bezpłatny", "value" => "unpaid_vacation"],
+                ["label" => "Wolontariat", "value" => "volunteering_vacation"],
+                ["label" => "Odbiór za święto", "value" => "time_in_lieu"],
+                ["label" => "Zwolnienie lekarskie", "value" => "sick_vacation"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+                ["label" => "Delegacja", "value" => "delegation"],
+            ]);
+    }
+
+    public function testCorrectVacationTypesAreAvailableForAdmin(): void
+    {
+        $admin = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
+            ->admin()
+            ->create();
+
+        $this->actingAs($admin)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $admin->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Urlop wypoczynkowy", "value" => "vacation"],
+                ["label" => "Urlop na żądanie", "value" => "vacation_on_request"],
+                ["label" => "Urlop okolicznościowy", "value" => "special_vacation"],
+                ["label" => "Opieka nad dzieckiem (art. 188 kp)", "value" => "childcare_vacation"],
+                ["label" => "Urlop szkoleniowy", "value" => "training_vacation"],
+                ["label" => "Urlop bezpłatny", "value" => "unpaid_vacation"],
+                ["label" => "Wolontariat", "value" => "volunteering_vacation"],
+                ["label" => "Odbiór za święto", "value" => "time_in_lieu"],
+                ["label" => "Zwolnienie lekarskie", "value" => "sick_vacation"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+                ["label" => "Delegacja", "value" => "delegation"],
+            ]);
+    }
+
+    public function testCorrectVacationTypesAreAvailableForCommissionContract(): void
+    {
+        $user = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::CommissionContract]))
+            ->create();
+
+        $this->actingAs($user)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $user->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Nieobecność", "value" => "absence"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+            ]);
+    }
+
+    public function testCorrectVacationTypesAreAvailableForB2bContract(): void
+    {
+        $user = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::B2bContract]))
+            ->create();
+
+        $this->actingAs($user)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $user->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Nieobecność", "value" => "absence"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+            ]);
+    }
+
+    public function testCorrectVacationTypesAreAvailableForBoardMemberContract(): void
+    {
+        $user = User::factory()
+            ->has(Profile::factory(["employment_form" => EmploymentForm::BoardMemberContract]))
+            ->create();
+
+        $this->actingAs($user)
+            ->post("/api/vacation/get-available-vacation-types", [
+                "user" => $user->id,
+            ])
+            ->assertOk()
+            ->assertJson([
+                ["label" => "Nieobecność", "value" => "absence"],
+                ["label" => "Praca zdalna", "value" => "remote_work"],
+            ]);
+    }
 }
diff --git a/tests/Unit/UnavailableDaysRetrieverTest.php b/tests/Unit/UnavailableDaysRetrieverTest.php
new file mode 100644
index 00000000..e24a46ba
--- /dev/null
+++ b/tests/Unit/UnavailableDaysRetrieverTest.php
@@ -0,0 +1,220 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit;
+
+use Illuminate\Database\Eloquent\Factories\Sequence;
+use Illuminate\Foundation\Testing\Concerns\InteractsWithSession;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Carbon;
+use Tests\TestCase;
+use Tests\Traits\InteractsWithYearPeriods;
+use Toby\Domain\Enums\Role;
+use Toby\Domain\Enums\VacationType;
+use Toby\Domain\PolishHolidaysRetriever;
+use Toby\Domain\States\VacationRequest\Approved;
+use Toby\Domain\UnavailableDaysRetriever;
+use Toby\Eloquent\Models\User;
+use Toby\Eloquent\Models\Vacation;
+use Toby\Eloquent\Models\VacationRequest;
+use Toby\Eloquent\Models\YearPeriod;
+
+class UnavailableDaysRetrieverTest extends TestCase
+{
+    use RefreshDatabase;
+    use InteractsWithSession;
+    use InteractsWithYearPeriods;
+
+    public UnavailableDaysRetriever $unavailableDaysRetriever;
+    public User $user;
+    public YearPeriod $yearPeriod;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->unavailableDaysRetriever = $this->app->make(UnavailableDaysRetriever::class);
+        $this->user = User::factory(["role" => Role::Employee])->create();
+        $this->yearPeriod = $this->createYearPeriod(2023);
+
+        $vacationRequest = VacationRequest::factory()
+            ->for($this->user)
+            ->for($this->yearPeriod)
+            ->create([
+                "from" => Carbon::parse("2023-07-05"),
+                "to" => Carbon::parse("2023-07-09"),
+                "state" => Approved::class,
+            ]);
+
+        Vacation::factory()
+            ->for($vacationRequest)
+            ->for($this->yearPeriod)
+            ->for($this->user)
+            ->count(5)
+            ->state(new Sequence(
+                ["date" => Carbon::parse("2023-07-05")],
+                ["date" => Carbon::parse("2023-07-06")],
+                ["date" => Carbon::parse("2023-07-07")],
+                ["date" => Carbon::parse("2023-07-08")],
+                ["date" => Carbon::parse("2023-07-09")],
+            ))
+            ->create();
+
+        $polishHolidaysRetriever = $this->app->make(PolishHolidaysRetriever::class);
+
+        foreach ($polishHolidaysRetriever->getForYearPeriod($this->yearPeriod) as $holiday) {
+            $this->yearPeriod->holidays()->create([
+                "name" => $holiday["name"],
+                "date" => $holiday["date"],
+            ]);
+        }
+    }
+
+    public function testRetrievesCorrectUnavailableDays(): void
+    {
+        $expectedUnavailableDays = [
+            "2023-01-01",
+            "2023-01-06",
+            "2023-01-07",
+            "2023-01-08",
+            "2023-01-14",
+            "2023-01-15",
+            "2023-01-21",
+            "2023-01-22",
+            "2023-01-28",
+            "2023-01-29",
+            "2023-02-04",
+            "2023-02-05",
+            "2023-02-11",
+            "2023-02-12",
+            "2023-02-18",
+            "2023-02-19",
+            "2023-02-25",
+            "2023-02-26",
+            "2023-03-04",
+            "2023-03-05",
+            "2023-03-11",
+            "2023-03-12",
+            "2023-03-18",
+            "2023-03-19",
+            "2023-03-25",
+            "2023-03-26",
+            "2023-04-01",
+            "2023-04-02",
+            "2023-04-08",
+            "2023-04-09",
+            "2023-04-10",
+            "2023-04-15",
+            "2023-04-16",
+            "2023-04-22",
+            "2023-04-23",
+            "2023-04-29",
+            "2023-04-30",
+            "2023-05-01",
+            "2023-05-03",
+            "2023-05-06",
+            "2023-05-07",
+            "2023-05-13",
+            "2023-05-14",
+            "2023-05-20",
+            "2023-05-21",
+            "2023-05-27",
+            "2023-05-28",
+            "2023-06-03",
+            "2023-06-04",
+            "2023-06-08",
+            "2023-06-10",
+            "2023-06-11",
+            "2023-06-17",
+            "2023-06-18",
+            "2023-06-24",
+            "2023-06-25",
+            "2023-07-01",
+            "2023-07-02",
+            "2023-07-05",
+            "2023-07-06",
+            "2023-07-07",
+            "2023-07-08",
+            "2023-07-09",
+            "2023-07-15",
+            "2023-07-16",
+            "2023-07-22",
+            "2023-07-23",
+            "2023-07-29",
+            "2023-07-30",
+            "2023-08-05",
+            "2023-08-06",
+            "2023-08-12",
+            "2023-08-13",
+            "2023-08-15",
+            "2023-08-19",
+            "2023-08-20",
+            "2023-08-26",
+            "2023-08-27",
+            "2023-09-02",
+            "2023-09-03",
+            "2023-09-09",
+            "2023-09-10",
+            "2023-09-16",
+            "2023-09-17",
+            "2023-09-23",
+            "2023-09-24",
+            "2023-09-30",
+            "2023-10-01",
+            "2023-10-07",
+            "2023-10-08",
+            "2023-10-14",
+            "2023-10-15",
+            "2023-10-21",
+            "2023-10-22",
+            "2023-10-28",
+            "2023-10-29",
+            "2023-11-01",
+            "2023-11-04",
+            "2023-11-05",
+            "2023-11-11",
+            "2023-11-12",
+            "2023-11-18",
+            "2023-11-19",
+            "2023-11-25",
+            "2023-11-26",
+            "2023-12-02",
+            "2023-12-03",
+            "2023-12-09",
+            "2023-12-10",
+            "2023-12-16",
+            "2023-12-17",
+            "2023-12-23",
+            "2023-12-24",
+            "2023-12-25",
+            "2023-12-26",
+            "2023-12-30",
+            "2023-12-31",
+        ];
+
+        $actualUnavailableDays = $this->unavailableDaysRetriever->getUnavailableDays($this->user, $this->yearPeriod)
+            ->map(fn(Carbon $date): string => $date->toDateString())
+            ->toArray();
+
+        $this->assertSame($expectedUnavailableDays, $actualUnavailableDays);
+    }
+
+    public function testRetrievesCorrectUnavailableDaysForNonWorkDaysVacation(): void
+    {
+        $expectedUnavailableDays = [
+            "2023-07-05",
+            "2023-07-06",
+            "2023-07-07",
+            "2023-07-08",
+            "2023-07-09",
+        ];
+
+        $actualUnavailableDays = $this->unavailableDaysRetriever
+            ->getUnavailableDays($this->user, $this->yearPeriod, VacationType::Delegation)
+            ->map(fn(Carbon $date): string => $date->toDateString())
+            ->toArray();
+
+        $this->assertSame($expectedUnavailableDays, $actualUnavailableDays);
+    }
+}
diff --git a/tests/Unit/WorkDaysCalculatorTest.php b/tests/Unit/WorkDaysCalculatorTest.php
new file mode 100644
index 00000000..9a988433
--- /dev/null
+++ b/tests/Unit/WorkDaysCalculatorTest.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit;
+
+use Illuminate\Foundation\Testing\Concerns\InteractsWithSession;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Carbon;
+use Tests\TestCase;
+use Tests\Traits\InteractsWithYearPeriods;
+use Toby\Domain\Enums\VacationType;
+use Toby\Domain\PolishHolidaysRetriever;
+use Toby\Domain\WorkDaysCalculator;
+
+class WorkDaysCalculatorTest extends TestCase
+{
+    use RefreshDatabase;
+    use InteractsWithSession;
+    use InteractsWithYearPeriods;
+
+    public WorkDaysCalculator $workDaysCalculator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->workDaysCalculator = $this->app->make(WorkDaysCalculator::class);
+
+        $yearPeriod = $this->createYearPeriod(2023);
+
+        $polishHolidaysRetriever = $this->app->make(PolishHolidaysRetriever::class);
+
+        foreach ($polishHolidaysRetriever->getForYearPeriod($yearPeriod) as $holiday) {
+            $yearPeriod->holidays()->create([
+                "name" => $holiday["name"],
+                "date" => $holiday["date"],
+            ]);
+        }
+    }
+
+    public function testCalculatesCorrectWorkDays(): void
+    {
+        $actualWorkDays = $this->workDaysCalculator->calculateDays(
+            Carbon::parse("2023-01-01"),
+            Carbon::parse("2023-12-31"),
+        );
+
+        $this->assertEquals(251, $actualWorkDays->count());
+    }
+
+    public function testCalculatesCorrectWorkDaysForDelegation(): void
+    {
+        $actualWorkDays = $this->workDaysCalculator->calculateDays(
+            Carbon::parse("2023-01-01"),
+            Carbon::parse("2023-12-31"),
+            VacationType::Delegation,
+        );
+
+        $this->assertEquals(365, $actualWorkDays->count());
+    }
+}