diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8454cc7..2be3e06 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2]
+
 ### Added
 * Add `Duration` struct to ease usage of delays and other methods using string duration formats
 * Add Default impl for `Duration`
@@ -27,6 +29,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Moved `ComRuntime` to `planif::com` module
 
 ## [0.2.1]
+
 ### Updated
 * Update documentation, add deny missing_docs
 
diff --git a/Cargo.toml b/Cargo.toml
index 961c3a0..a803e75 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT"
 repository = "https://github.com/mattrobineau/planif"
 version = "1.0.0"
 edition = "2021"
-keywords = ["scheduled", "task", "windows"]
+keywords = ["scheduled", "task", "windows", "schedule", "scheduler"]
 categories = ["os::windows-apis"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/examples/boot_task.rs b/examples/boot_task.rs
index d012467..a50b6b5 100644
--- a/examples/boot_task.rs
+++ b/examples/boot_task.rs
@@ -1,16 +1,16 @@
-use planif::enums::TaskCreationFlags;
-use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
+// use planif::enums::TaskCreationFlags;
+// use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
-    let sb = ScheduleBuilder::new(&com).unwrap();
-    sb.create_boot()
-        .author("Matt")?
-        .description("Test Time Trigger")?
-        .trigger("test_time_trigger", true)?
-        .action(Action::new("test_time_action", "notepad.exe", "", ""))?
-        .start_boundary("2022-04-28T02:14:08.660633427+00:00")?
-        .build()?
-        .register("TimeTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
-    Ok(())
-}
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
+//     let sb = ScheduleBuilder::new(&com).unwrap();
+//     sb.create_boot()
+//         .author("Matt")?
+//         .description("Test Time Trigger")?
+//         .trigger("test_time_trigger", true)?
+//         .action(Action::new("test_time_action", "notepad.exe", "", ""))?
+//         .start_boundary("2022-04-28T02:14:08.660633427+00:00")?
+//         .build()?
+//         .register("TimeTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     Ok(())
+// }
diff --git a/examples/daily_task.rs b/examples/daily_task.rs
index 4e0bafa..95e739d 100644
--- a/examples/daily_task.rs
+++ b/examples/daily_task.rs
@@ -1,20 +1,20 @@
-use chrono::prelude::*;
-use planif::enums::TaskCreationFlags;
-use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
+// use chrono::prelude::*;
+// use planif::enums::TaskCreationFlags;
+// use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
 
-    let sb = ScheduleBuilder::new(&com).unwrap();
-    sb.create_daily()
-        .author("Matt")?
-        .description("Test Trigger")?
-        .trigger("test_trigger", true)?
-        .days_interval(1)?
-        .action(Action::new("test", "notepad.exe", "", ""))?
-        .start_boundary(&Local::now().to_rfc3339())?
-        .build()?
-        .register("TaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     let sb = ScheduleBuilder::new(&com).unwrap();
+//     sb.create_daily()
+//         .author("Matt")?
+//         .description("Test Trigger")?
+//         .trigger("test_trigger", true)?
+//         .days_interval(1)?
+//         .action(Action::new("test", "notepad.exe", "", ""))?
+//         .start_boundary(&Local::now().to_rfc3339())?
+//         .build()?
+//         .register("TaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
 
-    Ok(())
-}
+//     Ok(())
+// }
diff --git a/examples/folder_task.rs b/examples/folder_task.rs
index ea9cc96..8d39e22 100644
--- a/examples/folder_task.rs
+++ b/examples/folder_task.rs
@@ -1,24 +1,24 @@
-use chrono::{Duration, Local};
-use planif::enums::TaskCreationFlags;
-use planif::schedule_builder::{Action, ScheduleBuilder};
+// use chrono::{Duration, Local};
+// use planif::enums::TaskCreationFlags;
+// use planif::schedule_builder::{Action, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let sb = ScheduleBuilder::new().unwrap();
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let sb = ScheduleBuilder::new().unwrap();
 
-    sb.create_time()
-        .author("Matt")?
-        .description("Test Time Trigger in folder")?
-        .in_folder("Test folder")?
-        .trigger("test_time_folder_trigger", true)?
-        .action(Action::new("test_time_action", "notepad.exe", "", ""))?
-        .start_boundary(
-            &Local::now()
-                .checked_add_signed(Duration::seconds(5))
-                .unwrap()
-                .to_rfc3339(),
-        )?
-        .build()?
-        .register("Time Folder Task", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     sb.create_time()
+//         .author("Matt")?
+//         .description("Test Time Trigger in folder")?
+//         .in_folder("Test folder")?
+//         .trigger("test_time_folder_trigger", true)?
+//         .action(Action::new("test_time_action", "notepad.exe", "", ""))?
+//         .start_boundary(
+//             &Local::now()
+//                 .checked_add_signed(Duration::seconds(5))
+//                 .unwrap()
+//                 .to_rfc3339(),
+//         )?
+//         .build()?
+//         .register("Time Folder Task", TaskCreationFlags::CreateOrUpdate as i32)?;
 
-    Ok(())
-}
+//     Ok(())
+// }
diff --git a/examples/logon_task.rs b/examples/logon_task.rs
index f85967e..af0fe6c 100644
--- a/examples/logon_task.rs
+++ b/examples/logon_task.rs
@@ -1,17 +1,17 @@
-use planif::enums::TaskCreationFlags;
-use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
+// use planif::enums::TaskCreationFlags;
+// use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
-    let sb = ScheduleBuilder::new(&com).unwrap();
-    sb.create_logon()
-        .author("Matt")?
-        .description("Test Time Trigger")?
-        .trigger("test_time_trigger", true)?
-        .action(Action::new("test_time_action", "notepad.exe", "", ""))?
-        .start_boundary("2022-04-28T02:14:08.660633427+00:00")?
-        .user_id("")?
-        .build()?
-        .register("TimeTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
-    Ok(())
-}
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
+//     let sb = ScheduleBuilder::new(&com).unwrap();
+//     sb.create_logon()
+//         .author("Matt")?
+//         .description("Test Time Trigger")?
+//         .trigger("test_time_trigger", true)?
+//         .action(Action::new("test_time_action", "notepad.exe", "", ""))?
+//         .start_boundary("2022-04-28T02:14:08.660633427+00:00")?
+//         .user_id("")?
+//         .build()?
+//         .register("TimeTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     Ok(())
+// }
diff --git a/examples/monthly_dow_task.rs b/examples/monthly_dow_task.rs
index 77d55c1..793e580 100644
--- a/examples/monthly_dow_task.rs
+++ b/examples/monthly_dow_task.rs
@@ -1,24 +1,24 @@
-use chrono::prelude::*;
-use planif::enums::{DayOfWeek, Month, TaskCreationFlags, WeekOfMonth};
-use planif::schedule_builder::{Action, ComRuntime, MonthlyDOW, ScheduleBuilder};
+// use chrono::prelude::*;
+// use planif::enums::{DayOfWeek, Month, TaskCreationFlags, WeekOfMonth};
+// use planif::schedule_builder::{Action, ComRuntime, MonthlyDOW, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
-    let builder: ScheduleBuilder<MonthlyDOW> = ScheduleBuilder::new(&com)?
-        .create_monthly_dow()
-        .author("Matt")?
-        .description("Test Trigger")?
-        .trigger("MyTrigger", true)?
-        .action(Action::new("test", "notepad.exe", "", ""))?
-        .months_of_year(vec![Month::January])?
-        .days_of_week(vec![DayOfWeek::Monday])?
-        .weeks_of_month(vec![WeekOfMonth::First])?
-        .start_boundary(&Local::now().to_rfc3339())?;
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
+//     let builder: ScheduleBuilder<MonthlyDOW> = ScheduleBuilder::new(&com)?
+//         .create_monthly_dow()
+//         .author("Matt")?
+//         .description("Test Trigger")?
+//         .trigger("MyTrigger", true)?
+//         .action(Action::new("test", "notepad.exe", "", ""))?
+//         .months_of_year(vec![Month::January])?
+//         .days_of_week(vec![DayOfWeek::Monday])?
+//         .weeks_of_month(vec![WeekOfMonth::First])?
+//         .start_boundary(&Local::now().to_rfc3339())?;
 
-    builder.build()?.register(
-        "MonthlyDOWTaskName",
-        TaskCreationFlags::CreateOrUpdate as i32,
-    )?;
+//     builder.build()?.register(
+//         "MonthlyDOWTaskName",
+//         TaskCreationFlags::CreateOrUpdate as i32,
+//     )?;
 
-    Ok(())
-}
+//     Ok(())
+// }
diff --git a/examples/monthly_task.rs b/examples/monthly_task.rs
index cf8a26b..9d521b0 100644
--- a/examples/monthly_task.rs
+++ b/examples/monthly_task.rs
@@ -1,22 +1,22 @@
-use chrono::prelude::*;
-use planif::enums::{DayOfMonth, Month, TaskCreationFlags};
-use planif::schedule_builder::{Action, ComRuntime, Monthly, ScheduleBuilder};
+// use chrono::prelude::*;
+// use planif::enums::{DayOfMonth, Month, TaskCreationFlags};
+// use planif::schedule_builder::{Action, ComRuntime, Monthly, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
-    let builder: ScheduleBuilder<Monthly> = ScheduleBuilder::new(&com)?
-        .create_monthly()
-        .author("Matt")?
-        .description("Test Trigger")?
-        .trigger("MyTrigger", true)?
-        .action(Action::new("test", "notepad.exe", "", ""))?
-        .days_of_month(vec![DayOfMonth::Day(1), DayOfMonth::Day(15)])?
-        .months_of_year(vec![Month::December])?
-        .start_boundary(&Local::now().to_rfc3339())?;
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
+//     let builder: ScheduleBuilder<Monthly> = ScheduleBuilder::new(&com)?
+//         .create_monthly()
+//         .author("Matt")?
+//         .description("Test Trigger")?
+//         .trigger("MyTrigger", true)?
+//         .action(Action::new("test", "notepad.exe", "", ""))?
+//         .days_of_month(vec![DayOfMonth::Day(1), DayOfMonth::Day(15)])?
+//         .months_of_year(vec![Month::December])?
+//         .start_boundary(&Local::now().to_rfc3339())?;
 
-    builder
-        .build()?
-        .register("MonthlyTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     builder
+//         .build()?
+//         .register("MonthlyTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
 
-    Ok(())
-}
+//     Ok(())
+// }
diff --git a/examples/multiple_tasks.rs b/examples/multiple_tasks.rs
index fee6fce..11ace76 100644
--- a/examples/multiple_tasks.rs
+++ b/examples/multiple_tasks.rs
@@ -1,34 +1,34 @@
-use chrono::prelude::*;
-use planif::enums::TaskCreationFlags;
-use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
+// use chrono::prelude::*;
+// use planif::enums::TaskCreationFlags;
+// use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
 
-    if true {
-    let sb = ScheduleBuilder::new(&com).unwrap();
-    sb.create_daily()
-        .author("Matt")?
-        .description("Test Trigger 1")?
-        .trigger("test_trigger_1", true)?
-        .days_interval(1)?
-        .action(Action::new("test", "notepad.exe", "", ""))?
-        .start_boundary(&Local::now().to_rfc3339())?
-        .build()?
-        .register("TaskName1", TaskCreationFlags::CreateOrUpdate as i32)?;
-    }
+//     if true {
+//     let sb = ScheduleBuilder::new(&com).unwrap();
+//     sb.create_daily()
+//         .author("Matt")?
+//         .description("Test Trigger 1")?
+//         .trigger("test_trigger_1", true)?
+//         .days_interval(1)?
+//         .action(Action::new("test", "notepad.exe", "", ""))?
+//         .start_boundary(&Local::now().to_rfc3339())?
+//         .build()?
+//         .register("TaskName1", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     }
 
-    if true {
-        let sb2 = ScheduleBuilder::new(&com).unwrap();
-        sb2.create_daily()
-            .author("Matt")?
-            .description("Test Trigger 2")?
-            .trigger("test_trigger_2", true)?
-            .days_interval(1)?
-            .action(Action::new("test", "notepad.exe", "", ""))?
-            .start_boundary(&Local::now().to_rfc3339())?
-            .build()?
-            .register("TaskName2", TaskCreationFlags::CreateOrUpdate as i32)?;
-    }
-    Ok(())
-}
+//     if true {
+//         let sb2 = ScheduleBuilder::new(&com).unwrap();
+//         sb2.create_daily()
+//             .author("Matt")?
+//             .description("Test Trigger 2")?
+//             .trigger("test_trigger_2", true)?
+//             .days_interval(1)?
+//             .action(Action::new("test", "notepad.exe", "", ""))?
+//             .start_boundary(&Local::now().to_rfc3339())?
+//             .build()?
+//             .register("TaskName2", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     }
+//     Ok(())
+// }
diff --git a/examples/various_settings_task.rs b/examples/various_settings_task.rs
index 0961426..65dcf5c 100644
--- a/examples/various_settings_task.rs
+++ b/examples/various_settings_task.rs
@@ -1,28 +1,24 @@
-use chrono::prelude::*;
-use planif::enums::TaskCreationFlags;
-<<<<<<< HEAD
-use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
-=======
-use planif::schedule_builder::{Action, ScheduleBuilder};
->>>>>>> origin/main
-use planif::settings::Settings;
+// use chrono::prelude::*;
+// use planif::enums::TaskCreationFlags;
+// use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
+// use planif::settings::Settings;
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
-    let sb = ScheduleBuilder::new(&com).unwrap();
-    let mut settings = Settings::new();
-    settings.run_only_if_idle = Some(true);
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
+//     let sb = ScheduleBuilder::new(&com).unwrap();
+//     let mut settings = Settings::new();
+//     settings.run_only_if_idle = Some(true);
 
-    sb.create_daily()
-        .author("Matt")?
-        .description("Test Trigger")?
-        .settings(settings)?
-        .trigger("test_trigger", true)?
-        .days_interval(1)?
-        .action(Action::new("test", "notepad.exe", "", ""))?
-        .start_boundary(&Local::now().to_rfc3339())?
-        .build()?
-        .register("TaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     sb.create_daily()
+//         .author("Matt")?
+//         .description("Test Trigger")?
+//         .settings(settings)?
+//         .trigger("test_trigger", true)?
+//         .days_interval(1)?
+//         .action(Action::new("test", "notepad.exe", "", ""))?
+//         .start_boundary(&Local::now().to_rfc3339())?
+//         .build()?
+//         .register("TaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
 
-    Ok(())
-}
+//     Ok(())
+// }
diff --git a/examples/weekly_task.rs b/examples/weekly_task.rs
index 83de740..06f8af9 100644
--- a/examples/weekly_task.rs
+++ b/examples/weekly_task.rs
@@ -1,19 +1,19 @@
-use chrono::prelude::*;
-use planif::enums::{ DayOfWeek, TaskCreationFlags };
-use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
+// use chrono::prelude::*;
+// use planif::enums::{ DayOfWeek, TaskCreationFlags };
+// use planif::schedule_builder::{Action, ComRuntime, ScheduleBuilder};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let com = ComRuntime::new()?;
-    let sb = ScheduleBuilder::new(&com).unwrap();
-    sb.create_weekly()
-        .author("Matt")?
-        .description("Test Weekly Trigger")?
-        .trigger("test_weekly_trigger", true)?
-        .action(Action::new("test", "notepad.exe", "", ""))?
-        .start_boundary(&Local::now().to_rfc3339())?
-        .days_of_week(vec![DayOfWeek::Sunday, DayOfWeek::Thursday])?
-        .weeks_interval(3)?
-        .build()?
-        .register("WeeklyTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
-    Ok(())
-}
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     let com = ComRuntime::new()?;
+//     let sb = ScheduleBuilder::new(&com).unwrap();
+//     sb.create_weekly()
+//         .author("Matt")?
+//         .description("Test Weekly Trigger")?
+//         .trigger("test_weekly_trigger", true)?
+//         .action(Action::new("test", "notepad.exe", "", ""))?
+//         .start_boundary(&Local::now().to_rfc3339())?
+//         .days_of_week(vec![DayOfWeek::Sunday, DayOfWeek::Thursday])?
+//         .weeks_interval(3)?
+//         .build()?
+//         .register("WeeklyTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
+//     Ok(())
+// }
diff --git a/src/lib.rs b/src/lib.rs
index 3227c5a..3d40578 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -48,20 +48,22 @@ pub mod schedule;
 pub mod schedule_builder;
 /// Various settings available while building [Schedules](schedule::Schedule).
 pub mod settings;
+/// The base struct used to manage all the others.
+pub mod task_scheduler;
 /// Com
 pub mod com;
 
 #[cfg(test)]
 mod tests {
+    use chrono::{Duration, Local};
+
+    use crate::{task_scheduler::{TaskScheduler}, enums::TaskCreationFlags, schedule_builder::Action};
 
     #[test]
     fn it_works() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::enums::TaskCreationFlags;
-        use crate::schedule_builder::{Action, ScheduleBuilder};
-        use chrono::prelude::*;
-        use chrono::Duration;
-
-        ScheduleBuilder::new()?
+        let ts = TaskScheduler::new();
+        ts
+            .create_schedule()
             .create_time()
             .author("Test dummy")?
             .description("Test Time Trigger")?
@@ -77,6 +79,13 @@ mod tests {
             .build()?
             .register("TimeTaskName", TaskCreationFlags::CreateOrUpdate as i32)?;
 
+        println!("{}", ts.get_schedule("\\Test folder\\TimeTaskName").path());
+
+        // ts.get_schedules_from_folder("Mozilla")
+        //     .unwrap()
+        //     .into_iter()
+        //     .for_each(|x| println!("{}", x.path()));
+
         Ok(())
     }
 }
diff --git a/src/schedule.rs b/src/schedule.rs
index 2175158..2124fcb 100644
--- a/src/schedule.rs
+++ b/src/schedule.rs
@@ -1,29 +1,37 @@
 use windows::core::BSTR;
 use windows::Win32::System::TaskScheduler::{
-    IActionCollection, IRegistrationInfo, ITaskDefinition, ITaskFolder, ITaskService,
+    IActionCollection, IRegistrationInfo, ITaskDefinition, ITaskFolder,
     ITaskSettings, ITrigger, ITriggerCollection, TASK_LOGON_INTERACTIVE_TOKEN,
 };
 use windows::Win32::System::Com::VARIANT;
 
 use crate::com::ComRuntime;
 
+/// Marker type for base [`Schedule<Unregistered>`]
+pub struct Unregistered {}
+
+/// Marker type for registered [`Schedule<Registered>`]
+pub struct Registered {}
+
 #[derive(Debug, PartialEq)]
 /// A schedule is created by a [schedule builder](crate::schedule_builder). Once created, the
 /// Schedule can be registered with the Windows Task Scheduler.
-pub struct Schedule {
+pub struct Schedule<Kind = Unregistered> {
+    pub(crate) kind: std::marker::PhantomData<Kind>,
     pub(crate) task_folder: ITaskFolder,
     pub(crate) actions: IActionCollection,
     pub(crate) force_start_boundary: bool,
-    pub(crate) registration_info: IRegistrationInfo,
+    pub(crate) registration_info: IRegistrationInfo, // maybe just this? since taskdef can come form it
     pub(crate) settings: ITaskSettings,
-    pub(crate) task_definition: ITaskDefinition,
-    pub(crate) task_service: ITaskService,
+    pub(crate) task_definition: ITaskDefinition, 
+    // pub(crate) task_service: ITaskService,
     pub(crate) trigger: Option<ITrigger>,
     pub(crate) triggers: ITriggerCollection,
+    pub(crate) com_runtime: ComRuntime,
     //repetition: IRepetitionPattern,
 }
 
-impl Schedule {
+impl Schedule<Unregistered> {
     /// Registers the schedule. Flags can be set by using the [TaskCreationFlags](crate::enums::TaskCreationFlags) enum.
     pub fn register(self, task_name: &str, flags: i32) -> Result<(), Box<dyn std::error::Error>> {
         unsafe {
@@ -38,7 +46,7 @@ impl Schedule {
                 VARIANT::default(),
             )?;
         }
-
+        
         Ok(())
     }
 }
@@ -76,3 +84,18 @@ impl TaskScheduler {
         self.com.clone()
     }
 }
+
+impl Schedule<Registered> {
+    /// more test
+    pub fn path(&self) -> String {
+        unsafe {
+            self.task_folder.Path().unwrap().to_string()
+        }
+    }
+
+    pub fn delete(self) {
+        unsafe {
+            self.task_folder.DeleteTask(self.)
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/schedule_builder.rs b/src/schedule_builder.rs
index 3be3936..4a222a5 100644
--- a/src/schedule_builder.rs
+++ b/src/schedule_builder.rs
@@ -1,10 +1,14 @@
 use crate::{
     enums::{DayOfMonth, DayOfWeek, Month, WeekOfMonth},
     error::{InvalidOperationError, RequiredPropertyError},
-    schedule::Schedule,
-    settings::{Duration, PrincipalSettings, Settings},
+    schedule::{Schedule, Unregistered},
+    settings::{Duration, PrincipalSettings, Settings}, task_scheduler::ComRuntime,
     com::ComRuntime,
 };
+
+use windows::core::ComInterface;
+use windows::core::BSTR;
+use windows::Win32::Foundation::VARIANT_BOOL;
 use windows::Win32::System::Com::{
     CoCreateInstance, CLSCTX_ALL, VARIANT,
 };
@@ -14,8 +18,7 @@ use windows::Win32::System::TaskScheduler::{
     IAction, IActionCollection, IBootTrigger, IDailyTrigger, IEventTrigger, IExecAction,
     IIdleTrigger, ILogonTrigger, IMonthlyDOWTrigger, IMonthlyTrigger, INetworkSettings, IPrincipal,
     IRegistrationInfo, IRegistrationTrigger, IRepetitionPattern, ITaskDefinition, ITaskFolder,
-    ITaskService, ITaskSettings, ITimeTrigger, ITrigger, ITriggerCollection, IWeeklyTrigger,
-    TaskScheduler, TASK_ACTION_EXEC, TASK_LOGON_TYPE, TASK_RUNLEVEL_TYPE, TASK_TRIGGER_BOOT,
+    ITaskService, ITaskSettings, ITimeTrigger, ITrigger, ITriggerCollection, IWeeklyTrigger, TASK_ACTION_EXEC, TASK_LOGON_TYPE, TASK_RUNLEVEL_TYPE, TASK_TRIGGER_BOOT,
     TASK_TRIGGER_DAILY, TASK_TRIGGER_EVENT, TASK_TRIGGER_IDLE, TASK_TRIGGER_LOGON,
     TASK_TRIGGER_MONTHLY, TASK_TRIGGER_MONTHLYDOW, TASK_TRIGGER_REGISTRATION, TASK_TRIGGER_TIME,
     TASK_TRIGGER_WEEKLY,
@@ -51,7 +54,8 @@ pub struct Weekly {}
 pub struct ScheduleBuilder<Frequency = Base> {
     pub(crate) frequency: std::marker::PhantomData<Frequency>,
     pub(crate) schedule: Schedule,
-    com: ComRuntime,
+    com_runtime: ComRuntime,
+    task_service: ITaskService
 }
 
 impl ScheduleBuilder<Base> {
@@ -64,17 +68,20 @@ impl ScheduleBuilder<Base> {
     /// let com = ComRuntime::new()?;
     /// let builder: ScheduleBuilder<Base> = ScheduleBuilder::new(&com).unwrap();
     /// ```
-    pub fn new(com: &ComRuntime) -> Result<Self, Box<dyn std::error::Error>> {
+    pub fn new(com_runtime: &ComRuntime, task_service: &ITaskService) -> Result<Self, Box<dyn std::error::Error>> {
         unsafe {
-            let sb_com = com.clone();
+            let sb_com_rt = com_runtime.clone();
+            let sb_ts = task_service.clone();
+
+            let sch_com_rt = com_runtime.clone();
 
-            let task_service: ITaskService = CoCreateInstance(&TaskScheduler, None, CLSCTX_ALL)?;
-            task_service.Connect(
-                VARIANT::default(),
-                VARIANT::default(),
-                VARIANT::default(),
-                VARIANT::default(),
-            )?;
+            // let task_service: ITaskService = CoCreateInstance(&TaskScheduler, None, CLSCTX_ALL)?;
+            // task_service.Connect(
+            //     VARIANT::default(),
+            //     VARIANT::default(),
+            //     VARIANT::default(),
+            //     VARIANT::default(),
+            // )?;
 
             let task_folder: ITaskFolder = task_service.GetFolder(&BSTR::from("\\"))?;
             let task_definition: ITaskDefinition = task_service.NewTask(0)?;
@@ -84,18 +91,21 @@ impl ScheduleBuilder<Base> {
             let settings: ITaskSettings = task_definition.Settings()?;
 
             Ok(Self {
-                com: sb_com,
+                com_runtime: sb_com_rt,
                 frequency: std::marker::PhantomData::<Base>,
+                task_service: sb_ts,
                 schedule: Schedule {
+                    kind: std::marker::PhantomData::<Unregistered>,
                     task_folder,
                     actions,
                     force_start_boundary: false,
                     registration_info,
                     settings,
-                    task_service,
+                    // task_service,
                     task_definition,
                     trigger: None,
                     triggers,
+                    com_runtime: sch_com_rt
                 },
             })
         }
@@ -114,9 +124,10 @@ impl ScheduleBuilder<Base> {
     /// ```
     pub fn create_boot(self) -> ScheduleBuilder<Boot> {
         ScheduleBuilder::<Boot> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Boot>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -134,9 +145,10 @@ impl ScheduleBuilder<Base> {
     pub fn create_daily(mut self) -> ScheduleBuilder<Daily> {
         self.schedule.force_start_boundary = true;
         ScheduleBuilder::<Daily> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Daily>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -154,9 +166,10 @@ impl ScheduleBuilder<Base> {
     pub fn create_event(mut self) -> ScheduleBuilder<Event> {
         self.schedule.force_start_boundary = true;
         ScheduleBuilder::<Event> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Event>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -173,9 +186,10 @@ impl ScheduleBuilder<Base> {
     /// ```
     pub fn create_idle(self) -> ScheduleBuilder<Idle> {
         ScheduleBuilder::<Idle> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Idle>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -192,9 +206,10 @@ impl ScheduleBuilder<Base> {
     /// ```
     pub fn create_logon(self) -> ScheduleBuilder<Logon> {
         ScheduleBuilder::<Logon> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Logon>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -210,9 +225,10 @@ impl ScheduleBuilder<Base> {
     /// ```
     pub fn create_monthly(self) -> ScheduleBuilder<Monthly> {
         ScheduleBuilder::<Monthly> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Monthly>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -229,9 +245,10 @@ impl ScheduleBuilder<Base> {
     pub fn create_monthly_dow(mut self) -> ScheduleBuilder<MonthlyDOW> {
         self.schedule.force_start_boundary = true;
         ScheduleBuilder::<MonthlyDOW> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<MonthlyDOW>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -247,9 +264,10 @@ impl ScheduleBuilder<Base> {
     /// ```
     pub fn create_registration(self) -> ScheduleBuilder<Registration> {
         ScheduleBuilder::<Registration> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Registration>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -267,9 +285,10 @@ impl ScheduleBuilder<Base> {
     pub fn create_time(mut self) -> ScheduleBuilder<Time> {
         self.schedule.force_start_boundary = true;
         ScheduleBuilder::<Time> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Time>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 
@@ -286,9 +305,10 @@ impl ScheduleBuilder<Base> {
     /// ```
     pub fn create_weekly(self) -> ScheduleBuilder<Weekly> {
         ScheduleBuilder::<Weekly> {
-            com: self.com,
+            com_runtime: self.com_runtime,
             frequency: std::marker::PhantomData::<Weekly>,
             schedule: self.schedule,
+            task_service: self.task_service
         }
     }
 }
@@ -313,10 +333,9 @@ impl<Frequency> ScheduleBuilder<Frequency> {
         unsafe {
             // check if folder exists, if not make it
             self.schedule.task_folder =
-                match self.schedule.task_service.GetFolder(&BSTR::from(folder)) {
+                match self.task_service.GetFolder(&BSTR::from(folder)) {
                     Ok(x) => x,
                     Err(_) => self
-                        .schedule
                         .task_service
                         .GetFolder(&BSTR::from("\\"))
                         .unwrap()
diff --git a/src/task_scheduler.rs b/src/task_scheduler.rs
new file mode 100644
index 0000000..cec1657
--- /dev/null
+++ b/src/task_scheduler.rs
@@ -0,0 +1,222 @@
+use std::mem::ManuallyDrop;
+use std::rc::Rc;
+
+use windows::core::BSTR;
+use windows::Win32::System::Com::*;
+use windows::Win32::System::TaskScheduler::*;
+
+use crate::schedule::Registered;
+use crate::schedule::Schedule;
+use crate::schedule_builder::Base;
+use crate::schedule_builder::ScheduleBuilder;
+
+// new plan
+// TaskScheduler struct which represents...the service?
+// can Get() a Schedule - an individual task
+// the Schedule can set the author and all the other things
+// can Save() a Schedule, persists the changes to the task scheduler and consumes it
+
+// TaskScheduler can call Create() which returns a Schedule
+// can set on all that
+// can register a schedule builder
+
+// remove schedulebuilder
+// make build just "finish" everything, validation
+// can change the marker type
+// and register takes a Final schedule
+
+// when you get a schedule its mostly valid
+// it
+
+/// Represents a COM runtime required for building [`TaskScheduler`s](task_scheduler::TaskScheduler)
+#[derive(Debug, PartialEq)]
+pub struct ComRuntime(Rc<Com>);
+
+impl ComRuntime {
+    /// Creates a COM runtime for use with one or more
+    /// [ScheduleBuilder]
+    pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
+        Ok(ComRuntime(Rc::new(Com::initialize()?)))
+    }
+}
+
+impl Clone for ComRuntime {
+    fn clone(&self) -> Self {
+        ComRuntime(Rc::clone(&self.0))
+    }
+}
+
+// impl Drop for ComRuntime {
+//     fn drop(&mut self) {
+//         if Rc::strong_count(&self.0) == 1 {
+//             println!("go time");
+//             unsafe {
+//                 CoUninitialize();
+//             }
+//         } else {
+//             println!("not time yet");
+//         }
+//     }
+// }
+
+#[derive(Debug, PartialEq)]
+struct Com;
+
+impl Com {
+    /// Allows us to just initialize once over the course of the program
+    fn initialize() -> Result<Self, Box<dyn std::error::Error>> {
+        unsafe {
+            CoInitializeEx(None, COINIT_MULTITHREADED)?;
+        }
+
+        Ok(Com)
+    }
+}
+
+impl Drop for Com {
+    fn drop(&mut self) {
+        println!("dropping com");
+        unsafe {
+            CoUninitialize();
+        }
+    }
+}
+
+/// The base struct, used for making Schedules and getting them
+pub struct TaskScheduler {
+    task_service: ITaskService,
+    com_runtime: ComRuntime,
+}
+
+impl TaskScheduler {
+    /// makes a new thing
+    pub fn new() -> Self {
+        let com = ComRuntime::new().unwrap();
+
+        unsafe {
+            let task_service: ITaskService =
+                CoCreateInstance(&TaskScheduler, None, CLSCTX_ALL).unwrap();
+
+            task_service
+                .Connect(
+                    VARIANT::default(),
+                    VARIANT::default(),
+                    VARIANT::default(),
+                    VARIANT::default(),
+                )
+                .unwrap();
+
+            TaskScheduler {
+                com_runtime: com,
+                task_service,
+            }
+        }
+    }
+
+    /// Create a new `ScheduleBuilder` that can be used to make a schedule.
+    pub fn create_schedule(&self) -> ScheduleBuilder<Base> {
+        ScheduleBuilder::new(&self.com_runtime, &self.task_service).unwrap()
+    }
+
+    /// Gets the task at the specified path, returns something on error
+    pub fn get_schedule(&self, path: &str) -> Schedule<Registered> {
+        let folder;
+        let name;
+
+        // if the name has no \, it is assumed to be in the root folder
+        match path.rsplit_once('\\') {
+            Some(x) if x.0.is_empty() => (folder, name) = ("\\", x.1),
+            Some(x) => (folder, name) = x,
+            None => {
+                folder = "\\";
+                name = path;
+            }
+        };
+
+        unsafe {
+            // TODO: match on "task not existing"
+            let com_runtime = self.com_runtime.clone();
+            let task_folder = self.task_service.GetFolder(&BSTR::from(folder)).unwrap();
+            let registered_task = task_folder.GetTask(&BSTR::from(name)).unwrap();
+            let task_definition = registered_task.Definition().unwrap();
+            let registration_info = task_definition.RegistrationInfo().unwrap();
+            let actions = task_definition.Actions().unwrap();
+            let settings = task_definition.Settings().unwrap();
+            let triggers = task_definition.Triggers().unwrap();
+
+            Schedule::<Registered> {
+                kind: std::marker::PhantomData::<Registered>,
+                task_folder,
+                task_definition,
+                registration_info,
+                actions,
+                force_start_boundary: false,
+                settings,
+                trigger: None,
+                triggers,
+                com_runtime,
+            }
+        }
+    }
+
+    /// Gets all the schedules in a folder
+    pub fn get_schedules_from_folder(&self, folder: &str) -> Option<Vec<Schedule<Registered>>> {
+        unsafe {
+            // TODO: match on "task not existing"
+            let task_folder = self.task_service.GetFolder(&BSTR::from(folder)).unwrap();
+
+            let task_collection = task_folder.GetTasks(TASK_ENUM_HIDDEN.0).unwrap();
+            let task_num = task_collection.Count().unwrap();
+
+            if task_num == 0 {
+                return None;
+            }
+
+            let mut schedules = Vec::with_capacity(task_num as usize);
+
+            for i in 0..task_num {
+                let index = VARIANT {
+                    Anonymous: VARIANT_0 {
+                        Anonymous: ManuallyDrop::new(VARIANT_0_0 {
+                            vt: VT_I4,
+                            wReserved1: 0,
+                            wReserved2: 0,
+                            wReserved3: 0,
+                            Anonymous: VARIANT_0_0_0 { lVal: i + 1 },
+                        }),
+                    },
+                };
+
+                let com_runtime = self.com_runtime.clone();
+                let registered_task = task_collection.get_Item(index).unwrap();
+
+                let task_definition = registered_task.Definition().unwrap();
+                let registration_info = task_definition.RegistrationInfo().unwrap();
+                let actions = task_definition.Actions().unwrap();
+                let settings = task_definition.Settings().unwrap();
+                let triggers = task_definition.Triggers().unwrap();
+
+                schedules.push(Schedule::<Registered> {
+                    kind: std::marker::PhantomData::<Registered>,
+                    task_folder: task_folder.clone(),
+                    task_definition,
+                    registration_info,
+                    actions,
+                    force_start_boundary: false,
+                    settings,
+                    trigger: None,
+                    triggers,
+                    com_runtime,
+                });
+            }
+
+            Some(schedules)
+        }
+    }
+}
+
+impl Default for TaskScheduler {
+    fn default() -> Self {
+        Self::new()
+    }
+}