Notion

0.2.0-preview0704

Notion.psm1

#Region './Enum/01_notion_color.ps1' -1

enum notion_color
# https://developers.notion.com/reference/block#callout
{
    blue
    blue_background
    brown
    brown_background
    default
    gray
    gray_background
    green
    green_background
    orange
    orange_background
    pink
    pink_background
    purple
    purple_background
    red
    red_background
    yellow
    yellow_background
}
#EndRegion './Enum/01_notion_color.ps1' 24
#Region './Enum/05_icontype.ps1' -1

enum icontype
# https://developers.notion.com/reference/page#page-object-properties

#BUG: ????
{
    notion_file
    emoji
}
#EndRegion './Enum/05_icontype.ps1' 9
#Region './Enum/Block/01_blocktype.ps1' -1

enum notion_blocktype
{
    bookmark
    breadcrumb
    bulleted_list_item
    callout
    child_database
    child_page
    code
    column
    column_list
    divider
    embed
    equation
    file
    heading_1
    heading_2
    heading_3
    image
    link_preview
    link_to_page
    numbered_list_item
    paragraph
    pdf
    quote
    synced_block
    table
    table_of_contents
    table_row
    template
    to_do
    toggle
    unsupported
    video
}
#EndRegion './Enum/Block/01_blocktype.ps1' 36
#Region './Enum/Block/RichText/01_rich_text_type.ps1' -1

enum rich_text_type
{
    text
    mention
    equation
}
#EndRegion './Enum/Block/RichText/01_rich_text_type.ps1' 7
#Region './Enum/Block/RichText/02_rich_text_mention_type.ps1' -1

# https://developers.notion.com/reference/rich-text#mention
enum rich_text_mention_type {
    database
    date
    link_preview
    page
    template_mention
    user
}
#EndRegion './Enum/Block/RichText/02_rich_text_mention_type.ps1' 10
#Region './Enum/Block/RichText/Type/MentionType/01_template_Mention_Date.ps1' -1

enum template_mention_date
{
    today
    now
}
#EndRegion './Enum/Block/RichText/Type/MentionType/01_template_Mention_Date.ps1' 6
#Region './Enum/DatabaseProperties/01_db_DatabasePropertyType.ps1' -1

enum notion_database_property_type
{
    checkbox
    created_by
    created_time
    date
    email
    files
    formula
    last_edited_by
    last_edited_time
    multi_select
    number
    people
    phone_number
    relation
    rich_text
    rollup
    select
    status
    title
    url
    unique_id
}
#EndRegion './Enum/DatabaseProperties/01_db_DatabasePropertyType.ps1' 25
#Region './Enum/DatabaseProperties/02_db_DatabasePropertyFormatType.ps1' -1

enum notion_database_property_format_type
# https://developers.notion.com/reference/property-object#number
{
    argentine_peso
    baht
    australian_dollar
    canadian_dollar
    chilean_peso
    colombian_peso
    danish_krone
    dirham
    dollar
    euro
    forint
    franc
    hong_kong_dollar
    koruna
    krona
    leu
    lira
    mexican_peso
    new_taiwan_dollar
    new_zealand_dollar
    norwegian_krone
    number
    number_with_commas
    percent
    philippine_peso
    pound
    peruvian_sol
    rand
    real
    ringgit
    riyal
    ruble
    rupee
    rupiah
    shekel
    singapore_dollar
    uruguayan_peso
    yen
    yuan
    won
    zloty
}
#EndRegion './Enum/DatabaseProperties/02_db_DatabasePropertyFormatType.ps1' 46
#Region './Enum/DatabaseProperties/03_db_DatabasePropertyRelationType.ps1' -1

enum notion_database_relation_type
# https://developers.notion.com/page/changelog#database-relations-have-a-type-of-single_property-and-dual_property
# only mentioned in release notes, not in API documentation
{
    single_property
    dual_property
}
#EndRegion './Enum/DatabaseProperties/03_db_DatabasePropertyRelationType.ps1' 8
#Region './Enum/File/01_Notion_Filetype.ps1' -1

# https://developers.notion.com/reference/file-object
enum notion_filetype {
    file
    external
}
#EndRegion './Enum/File/01_Notion_Filetype.ps1' 6
#Region './Enum/PageProperties/00_Page_Property_Type.ps1' -1


enum notion_page_property_type
{
    checkbox
    created_by
    created_time
    date
    email
    files
    formula
    last_edited_by
    last_edited_time
    multi_select
    number
    people
    phone_number
    relation
    rich_text
    rollup
    select
    status
    title
    url
    unique_id
    verification
}
#EndRegion './Enum/PageProperties/00_Page_Property_Type.ps1' 27
#Region './Enum/PageProperties/06_Page_Property_Verification_State.ps1' -1

enum notion_page_verification_state
{
    unverified
    verified
}
#EndRegion './Enum/PageProperties/06_Page_Property_Verification_State.ps1' 6
#Region './Enum/Parent/00_parent_type.ps1' -1

enum notion_parent_type {
    database_id
    page_id
    workspace
    block_id
}
#EndRegion './Enum/Parent/00_parent_type.ps1' 7
#Region './Enum/Properties/01_Property_Color.ps1' -1

enum notion_property_color
{
    default
    gray
    brown
    orange
    yellow
    green
    blue
    purple
    pink
    red
}
#EndRegion './Enum/Properties/01_Property_Color.ps1' 14
#Region './Enum/Properties/03_Property_Formula_Type.ps1' -1

enum notion_formula_type
{
    boolean
    date
    number
    string
}
#EndRegion './Enum/Properties/03_Property_Formula_Type.ps1' 8
#Region './Enum/Properties/04_Property_Rollup_Type.ps1' -1

enum notion_rollup_type
{
    array
    date
    incomplete
    number
    unsupported
}
#EndRegion './Enum/Properties/04_Property_Rollup_Type.ps1' 9
#Region './Enum/Properties/05_Property_Rollup_Function_Type.ps1' -1

#TODO: Wo gehört das hin??
# enum notion_page_rollup_function
# {
# count_all
# count_values
# count_unique_values
# count_empty
# count_not_empty
# percent_empty
# percent_not_empty
# sum
# average
# median
# min
# max
# range
# show_original
# }

enum notion_rollup_function_type
{
    average
    checked
    count
    count_per_group
    count_values
    date_range
    earliest_date
    empty
    latest_date
    max
    median
    min
    not_empty
    percent_checked
    percent_empty
    percent_not_empty
    percent_per_group
    percent_unchecked
    range
    show_original
    show_unique
    sum
    unchecked
    unique
}
#EndRegion './Enum/Properties/05_Property_Rollup_Function_Type.ps1' 47
#Region './Enum/User/01_bot_owner_type.ps1' -1

enum bot_owner_type
# https://developers.notion.com/reference/user#bots
{
    workspace
    user
}
#EndRegion './Enum/User/01_bot_owner_type.ps1' 7
#Region './Classes/00_General/00_icon.ps1' -1

class notion_icon
{
    # https://developers.notion.com/reference/page

    static [notion_icon] ConvertFromObject($Value)
    {
        if($null -eq $Value)
        {
            return $null
        }
        $icon_obj = $null
        switch ($Value.type)
            {
                # not supported according to the documentation, but it is returned by the API
                "file"
                {
                    $icon_obj = [notion_hosted_file]::ConvertFromObject($Value)
                }
                "external"
                {
                    $icon_obj = [notion_external_file]::ConvertFromObject($Value)
                }
                "emoji"
                {
                    $icon_obj = [notion_emoji]::new($Value) 
                }
                default
                {
                    Write-Error "Unknown icon type $($Value.type)" -Category InvalidData -TargetObject $Value -RecommendedAction "Please provide a valid icon type (file, external or emoji)"
                }
            }
        return $icon_obj
    }

}
#EndRegion './Classes/00_General/00_icon.ps1' 36
#Region './Classes/00_General/09_notion_formula.ps1' -1

class notion_formula
{
    [notion_formula_type] $type

    notion_formula([notion_formula_type]$type)
    {
        $this.type = $type
    }

    static [notion_formula] ConvertFromObject($Value)
    {
        $notion_fomula_obj = $null
        switch ($Value.type)
        {
            "boolean"
            {
                $notion_fomula_obj = [notion_formula_boolean]::ConvertFromObject($Value) 
            }
            "date"
            {
                $notion_fomula_obj = [notion_formula_date]::ConvertFromObject($Value) 
            }
            "number"
            {
                $notion_fomula_obj = [notion_formula_number]::ConvertFromObject($Value) 
            }
            "string"
            {
                $notion_fomula_obj = [notion_formula_string]::ConvertFromObject($Value) 
            }
            default
            { 
                Write-Error "Unknown formula type: $($Value.type)" -Category InvalidData -RecommendedAction "Check the formula type and try again. Supported types are boolean, date, number, and string."
            }
        }
        return $notion_fomula_obj
    }
}

class notion_formula_boolean : notion_formula
{
    [bool] $boolean

    notion_formula_boolean([bool]$value) : base([notion_formula_type]::boolean)
    {
        $this.boolean = $value
    }

    static [notion_formula_boolean] ConvertFromObject($Value)
    {
        return [notion_formula_boolean]::new($Value.boolean)
    }
}

class notion_formula_date : notion_formula
{
    [datetime] $date

    notion_formula_date($value) : base([notion_formula_type]::date)
    {
        if (!$value)
        {
            $this.date = $null; return 
        }
        if ($value -is [datetime])
        {
            $this.date = $value.ToUniversalTime()
        }
        else
        {
            $this.date = [datetime]::Parse($value).ToUniversalTime()
        }
    }

    static [notion_formula_date] ConvertFromObject($Value)
    {
        return [notion_formula_date]::new($Value.date)
    }
}

class notion_formula_number : notion_formula
{
    [double] $number

    notion_formula_number([double]$value) : base([notion_formula_type]::number)
    {
        $this.number = $value
    }

    static [notion_formula_number] ConvertFromObject($Value)
    {
        return [notion_formula_number]::new($Value.number)
    }
}

class notion_formula_string : notion_formula
{
    [string] $string

    notion_formula_string([string]$value) : base([notion_formula_type]::string)
    {
        $this.string = $value
    }

    static [notion_formula_string] ConvertFromObject($Value)
    {
        return [notion_formula_string]::new($Value.string)
    }
}
#EndRegion './Classes/00_General/09_notion_formula.ps1' 110
#Region './Classes/00_General/12_multi_select_item.ps1' -1

class notion_multi_select_item
# https://developers.notion.com/reference/property-object#multi-select
# If the type of a page property value is "multi_select", then the property value contains a "multi_select" array.
{
    [notion_property_color] $color
    [string] $id
    [string] $name

    notion_multi_select_item() 
    {
        $this.color = [notion_property_color]::default
    }

    notion_multi_select_item([notion_property_color]$color, $name)
    {
        $this.color = [Enum]::Parse([notion_property_color], $color)
        $this.id = [guid]::NewGuid().ToString()
        $this.name = $name
    }

    notion_multi_select_item($id,[notion_property_color]$color, $name)
    {
        $this.color = [Enum]::Parse([notion_property_color], $color)
        $this.id = $id
        $this.name = $name
    }

    static [notion_multi_select_item] ConvertFromObject($Value)
    {
        return [notion_multi_select_item]::new($Value.id, $Value.color, $Value.name)
    }       
}
#EndRegion './Classes/00_General/12_multi_select_item.ps1' 33
#Region './Classes/00_General/17_notion_rollup.ps1' -1

class notion_rollup{
    [notion_rollup_function_type] $function
    [notion_rollup_type] $type

    notion_rollup()
    {

    }

    notion_rollup_ ($type_value, $function, $type)
    {
        $this.$type = $type_value
        $this.function = [Enum]::Parse([notion_rollup_function_type], $function)
        $this.type = [Enum]::Parse([notion_rollup_type], $type)
    }

    static [notion_rollup] ConvertFromObject($Value)
    {
        if(!$value.type){
            return $null
        }
        $rollup_obj = $null
        switch ($value.type) {
            "array" {
                $rollup_obj = [notion_rollup_array]::ConvertFromObject($Value)
            }
            "date" {
                $rollup_obj = [notion_rollup_date]::ConvertFromObject($Value)
            }
            "incomplete" {
                $rollup_obj = [notion_rollup_incomplete]::ConvertFromObject($Value)
            }
            "number" {
                $rollup_obj = [notion_rollup_number]::ConvertFromObject($Value)
            }
            "unsupported" {
                $rollup_obj = [notion_rollup_unsupported]::ConvertFromObject($Value)
            }
        }
        $rollup_obj.function = [Enum]::Parse([notion_rollup_function_type], $Value.function)
        $rollup_obj.type = [Enum]::Parse([notion_rollup_type], $Value.type)
        return $rollup_obj
    }
}

class notion_rollup_array: notion_rollup
{
    [Object[]] $array

    notion_rollup_array()
    {

    }

    notion_rollup_array($array)
    {
        $this.array = $array
    }

    static [notion_rollup_array] ConvertFromObject($Value)
    {
        return [notion_rollup_array]::new($Value.array)
    }
}

class notion_rollup_date: notion_rollup
{
    [string] $date

    notion_rollup_date()
    {

    }

    notion_rollup_date($date)
    {
        $this.date = ConvertTo-NotionFormattedDateTime -InputDate $date -fieldName "date"
    }

    static [notion_rollup_date] ConvertFromObject($Value)
    {
        return [notion_rollup_date]::new($Value.date)
    }
}

class notion_rollup_incomplete: notion_rollup
{
    [object] $incomplete

    notion_rollup_incomplete()
    {

    }

    notion_rollup_incomplete($incomplete)
    {
        $this.incomplete = $incomplete
    }

    static [notion_rollup_incomplete] ConvertFromObject($Value)
    {
        return [notion_rollup_incomplete]::new($Value.incomplete)
    }
}

class notion_rollup_number: notion_rollup
{
    [int] $number

    notion_rollup_number()
    {

    }

    notion_rollup_number($number)
    {
        $this.number = $number
    }

    static [notion_rollup_number] ConvertFromObject($Value)
    {
        return [notion_rollup_number]::new($Value.number)
    }
}

class notion_rollup_unsupported: notion_rollup
{
    [object] $unsupported

    notion_rollup_unsupported()
    {

    }

    notion_rollup_unsupported($unsupported)
    {
        $this.unsupported = $unsupported
    }

    static [notion_rollup_unsupported] ConvertFromObject($Value)
    {
        return [notion_rollup_unsupported]::new($Value.unsupported)
    }
}

    
#EndRegion './Classes/00_General/17_notion_rollup.ps1' 147
#Region './Classes/00_General/19_notion_select.ps1' -1

class notion_select
{
    [notion_color] $color
    [string] $id
    [string] $name

    notion_select() 
    {

    }


    notion_select ($color, $id, $name)
    {
        $this.color = [Enum]::Parse([notion_color], $color)
        $this.id = $id
        $this.name = $name
    }

    static [notion_select] ConvertFromObject($Value)
    {
        return [notion_select]::new($Value.color, $Value.id, $Value.name)
    }
}
#EndRegion './Classes/00_General/19_notion_select.ps1' 25
#Region './Classes/00_General/20_notion_status.ps1' -1

class notion_status
# https://developers.notion.com/reference/page-property-values#status
{
    [notion_property_color] $color
    [string] $id
    [string] $name

    notion_status($name) 
    {
        $this.color = [notion_property_color]::default
        $this.id = $null
        $this.name = $name
    }

    notion_status($color, $name)
    {
        $this.color = [Enum]::Parse([notion_property_color], $color)
        $this.name = $name
    }

    notion_status($color, $id, $name)
    {
        $this.color = [Enum]::Parse([notion_property_color], $color)
        $this.id = $id
        $this.name = $name
    }

    static [notion_status] ConvertFromObject($Value)
    {
        return [notion_status]::new($Value.color, $Value.id, $Value.name)
    }
}
#EndRegion './Classes/00_General/20_notion_status.ps1' 33
#Region './Classes/01_User/01_user.ps1' -1

class notion_user : System.IComparable, System.IEquatable[object]
{
    # https://developers.notion.com/reference/user
    [string]$object = "user"
    [string]$id
    [string]$type
    [string]$name
    [string]$avatar_url

    notion_user()
    {
    }

    notion_user([object]$user)
    {
        $this.id = $user.id
        $this.type = $user.type
        $this.name = $user.name
        $this.avatar_url = $user.avatar_url
    }

    notion_user([string]$id)
    {
        $this.id = $id
    }

    [int] CompareTo([object]$other)
    {
        if ($null -eq $other)
        {
            return 1
        }
        if ($other -isnot [notion_user])
        {
            throw [System.ArgumentException]::new("The argument must be a user object.")
        }
        # Compare this instance with other based on id, name, type and avatar_url
        if ($this.id -eq $other.id -and $this.name -eq $other.name -and $this.type -eq $other.type -and $this.avatar_url -eq $other.avatar_url)
        {
            return 0
        }
        else
        {
            return -1
        }
    }
    [bool] Equals([object]$other)
    {
        # Check if the other object is a user and if it is equal to this instance
        if ($other -is [notion_user])
        {
            return $this.CompareTo($other) -eq 0
        }
        return $false
    }

    static [notion_user] ConvertFromObject($Value)
    {
        $user = [notion_user]::new()
        $user.id = $Value.id
        $user.type = $Value.type
        $user.name = $Value.name
        $user.avatar_url = $Value.avatar_url
        return $user
    }
}
#EndRegion './Classes/01_User/01_user.ps1' 67
#Region './Classes/01_User/02_people.ps1' -1

class notion_people_user : notion_user
{
    # https://developers.notion.com/reference/user#people
    [string]$person
    [string]$person_email

    notion_people_user()
    {
    }

    
    static [notion_people_user] ConvertFromObject($Value)
    {
        # $people.person = [notion_people_user]::new($value)
        # $people.person.email = $Value.email
        # return $people
        return $null
    }
}
#EndRegion './Classes/01_User/02_people.ps1' 20
#Region './Classes/01_User/03_bot.ps1' -1

class notion_bot_user : notion_user
# https://developers.notion.com/reference/user#bots
{
    $bot
    $owner
    [string] $workspace_name

    notion_bot_user()
    {
        Write-Warning "This object is for display only."
    }

    static [notion_bot_user] ConvertFromObject ($Value)
    {
        $obj = [PSCustomObject]::new()
        $obj = $Value.bot
        $obj.owner = $Value.owner
        $obj.owner.type = [Enum]::Parse([bot_owner_type], $Value.owner.type)
        $obj.workspace_name = $Value.workspace_name
        return $obj
    }
}
#EndRegion './Classes/01_User/03_bot.ps1' 23
#Region './Classes/02_Page/01_page.ps1' -1

class notion_page
{
    #https://developers.notion.com/reference/page
    [string]     $object = "page"
    [string]     $id
    [string]     $created_time
    [notion_user]       $created_by
    [string]     $last_edited_time
    [notion_user]       $last_edited_by
    [bool]       $archived
    [bool]       $in_trash
    [notion_icon]      $icon
    [notion_file]    $cover
    [notion_pageproperties] $properties = @{}
    [notion_parent]    $parent
    [string]     $url
    [string]     $public_url
    [string]     $request_id

    #Constructors
    notion_page()
    {
        $this.id = [guid]::NewGuid().ToString()
        $this.created_time = [datetime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
    }

    notion_page([string]$title)
    {
        $this.id = [guid]::NewGuid().ToString()
        $this.created_time = [datetime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
        $this.properties = [notion_title_page_property]::new($title)
    }


    notion_page([System.Object]$parent, $properties)
    {
        $this.created_time = [datetime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
        if($parent -is [notion_parent])
        {
            $this.parent = $parent
        }
        else
        {
            $this.parent = [notion_parent]::ConvertFromObject($parent)
        }
        $this.properties = $properties
    }

    static [notion_page] ConvertFromObject($Value)
    {
        if (($Value -is [System.Object]) -and !($Value -is [string]) -and !($Value -is [int]) -and !($Value -is [bool]) -and $Value.Object -and ($Value.Object -eq "page"))
        {
            $page = [notion_page]::new()
            $page.id = $Value.id
            $page.created_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.created_time -fieldName "created_time"
            $page.created_by = [notion_user]::ConvertFromObject($Value.created_by)
            $page.last_edited_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.last_edited_time -fieldName "last_edited_time"
            $page.last_edited_by = [notion_user]::ConvertFromObject($Value.last_edited_by)
            $page.archived = $Value.archived
            $page.in_trash = $Value.in_trash
            #$page.icon = $Value.icon
            $page.icon = [notion_icon]::ConvertFromObject($Value.icon)
            
            $page.cover = [notion_file]::ConvertFromObject($Value.cover) 
            # https://developers.notion.com/reference/page-property-values#paginated-page-properties
            #TODO Konvertierung aller Properties in Klassen
            $page.properties = [notion_pageproperties]::ConvertFromObject($Value.properties)
            # $page.properties = $Value.properties
            $page.parent = [notion_parent]::ConvertFromObject($Value.parent)
            $page.url = $Value.url
            $page.public_url = $Value.public_url
            $page.archived = $Value.archived ? $Value.archived : $false
            $page.in_trash = $Value.in_trash ? $Value.in_trash : $false
            $page.request_id = $Value.request_id ? $Value.request_id : $null
            return $page
        }
        else
        {
            if ($Value.Object -ne "page")
            {
                "Provided value's object type is ""$($Value.Object)"" instead of ""page""" | Add-NotionLogToFile -Level ERROR
            }
            else
            {
                "Provided value is type [$($Value.GetType().Name)] instead of [object]" | Add-NotionLogToFile -Level ERROR
            }
            return $null
        }
    }

    # static [notion_page] ConvertToISO8601($date)
    # {
    # Write-Output $date
    # return (Get-Date $date -Format "yyyy-MM-ddTHH:mm:ss.fffZ" )
    # }
}
#EndRegion './Classes/02_Page/01_page.ps1' 97
#Region './Classes/02_Page/04_page_reference.ps1' -1

class notion_page_reference{
    [string] $id

    notion_page_reference([string]$id)
    {
        $this.id = $id
    }

    static [notion_page_reference] ConvertFromObject($Value)
    {
        return [notion_page_reference]::new($Value.id)
    }
}
#EndRegion './Classes/02_Page/04_page_reference.ps1' 14
#Region './Classes/02_Page/PageProperties/00_pp_base.ps1' -1

class PagePropertiesBase {
    #https://developers.notion.com/reference/page-property-values
    [string] $id
    [notion_page_property_type] $type

    PagePropertiesBase([notion_page_property_type]$type)
    {
        $this.type = $type
    }

    PagePropertiesBase([string]$id, [notion_page_property_type]$type)
    {
        $this.id = $id
        $this.type = $type
    }

    static [PagePropertiesBase] ConvertFromObject($Value)
    {
        $base_obj = $null
        #TODO: Test if it works for @{}
        if ($value.count -gt 0) {
            switch ($Value.type)
            {
                "checkbox" { $base_obj = [notion_checkbox_page_property]::ConvertFromObject($Value); break }
                "created_by" { $base_obj = [notion_created_by_page_property]::ConvertFromObject($Value); break }
                "created_time" { $base_obj = [notion_created_time_page_property]::ConvertFromObject($Value); break }
                "date" { $base_obj = [notion_date_page_property]::ConvertFromObject($Value); break }
                "email" { $base_obj = [notion_email_page_property]::ConvertFromObject($Value); break }
                "files" { $base_obj = [notion_files_page_property]::ConvertFromObject($Value); break }
                "formula" { $base_obj = [notion_formula_page_property]::ConvertFromObject($Value); break }
                "last_edited_by" { $base_obj = [notion_last_edited_by_page_property]::ConvertFromObject($Value); break }
                "last_edited_time" { $base_obj = [notion_last_edited_time_page_property]::ConvertFromObject($Value); break }
                "multi_select" { $base_obj = [notion_multi_select_page_property]::ConvertFromObject($Value); break }
                "number" { $base_obj = [notion_number_page_property]::ConvertFromObject($Value); break }
                "people" { $base_obj = [notion_people_page_property]::ConvertFromObject($Value); break }
                "phone_number" { $base_obj = [notion_phone_number_page_property]::ConvertFromObject($Value); break }
                "relation" { $base_obj = [notion_relation_page_property]::ConvertFromObject($Value); break }
                "rollup" { $base_obj = [notion_rollup_page_property]::ConvertFromObject($Value); break }
                "rich_text" { $base_obj = [notion_rich_text_page_property]::ConvertFromObject($Value); break }
                "select" { $base_obj = [notion_select_page_property]::ConvertFromObject($Value); break }
                "status" { $base_obj = [notion_status_page_property]::ConvertFromObject($Value); break }
                "title" { $base_obj = [notion_title_page_property]::ConvertFromObject($Value); break }
                "url" { $base_obj = [notion_url_page_property]::ConvertFromObject($Value); break }
                "unique_id" { $base_obj = [notion_unique_id_page_property]::ConvertFromObject($Value); break }
                "verification" { $base_obj = [notion_verification_page_property]::ConvertFromObject($Value); break }
                default {
                    Write-Error "Unknown property: $($Value.type)" -Category InvalidData -RecommendedAction "Check the type of the property"
                }
            }
            try {
                $base_obj.id = $Value.id
                $base_obj.type = $Value.type
            }
            catch {
                Write-Error "Error setting id and type" -Category InvalidData -RecommendedAction "Check the id and type" -TargetObject $Value
            }
        }
        return $base_obj
    }
}
#EndRegion './Classes/02_Page/PageProperties/00_pp_base.ps1' 61
#Region './Classes/02_Page/PageProperties/01_pp.ps1' -1

class notion_pageproperties : hashtable
# https://developers.notion.com/reference/page-property-values
{
    #[notion_page_property_type] $Type

    notion_pageproperties()
    {
    }

    [void] Add([object] $Key, [object] $Value)
    {
        if (-not ($Value -is [PagePropertiesBase]))
        {
            Write-Error "Value must be of type PagePropertiesBase" -Category InvalidType -TargetObject $Value -RecommendedAction "Use a class that inherits from PagePropertiesBase"
        }
        # Call the base Add method
        ([hashtable] $this).Add($Key, $Value)
    }

    static [notion_pageproperties] ConvertFromObject($Value)
    {
        $pageproperties = [notion_pageproperties]::new()
        foreach ($key in $Value.PSObject.Properties.Name)
        {
            $pageproperties.Add($key, [PagePropertiesBase]::ConvertFromObject($Value.$key))
        }
        return $pageproperties
    }

    
}
#EndRegion './Classes/02_Page/PageProperties/01_pp.ps1' 32
#Region './Classes/02_Page/PageProperties/02_pp_checkbox.ps1' -1

class notion_checkbox_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#checkbox
{
    [bool] $checkbox = $false

    notion_checkbox_page_property([bool]$checkbox) : base("checkbox")
    {
        $this.checkbox = $checkbox
    }


    static [notion_checkbox_page_property] ConvertFromObject($Value)
    {
        $notion_checkbox_page_property = [notion_checkbox_page_property]::new($Value.checkbox)
        return $notion_checkbox_page_property
    }
}
#EndRegion './Classes/02_Page/PageProperties/02_pp_checkbox.ps1' 18
#Region './Classes/02_Page/PageProperties/03_pp_created_by.ps1' -1

class notion_created_by_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#created-by
{
    [notion_user] $created_by
    
    notion_created_by_page_property($created_by) : base("created_by")
    {
        if($created_by -eq $null)
        {
            $this.created_by = $null
            return
        }
        if($created_by -is [notion_user])
        {
            $this.created_by = $created_by
        }
        else{
            $this.created_by = [notion_user]::ConvertFromObject($created_by)
        }
    }

    static [notion_created_by_page_property] ConvertFromObject($Value)
    {
        $created_by_obj = [notion_created_by_page_property]::new($Value.created_by)
        return $created_by_obj
    }
}
#EndRegion './Classes/02_Page/PageProperties/03_pp_created_by.ps1' 28
#Region './Classes/02_Page/PageProperties/04_pp_created_time.ps1' -1

class notion_created_time_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#created-time
{
    [string] $created_time

    notion_created_time_page_property() : base("created_time")
    {
        $this.created_time = Get-Date -Format "yyyy-MM-ddTHH:mm:ss.fffZ" -AsUTC
    }

    notion_created_time_page_property([string]$created_time) : base("created_time")
    {
        $this.created_time = ConvertTo-NotionFormattedDateTime -InputDate $created_time -fieldName "created_time"
    }

    static [notion_created_time_page_property] ConvertFromObject($Value)
    {
        $created_time_obj = [notion_created_time_page_property]::new()
        $created_time_obj.created_time = $Value.created_time
        return $created_time_obj
    }
}
#EndRegion './Classes/02_Page/PageProperties/04_pp_created_time.ps1' 23
#Region './Classes/02_Page/PageProperties/05_pp_date.ps1' -1

class notion_date_page_property_structure 
# https://developers.notion.com/reference/page-property-values#date
{
    [string] $end
    [string] $start

    notion_date_page_property_structure() 
    {
        
    }

    notion_date_page_property_structure($start, $end)
    {
        $this.start = ConvertTo-NotionFormattedDateTime -InputDate $start -fieldName "start"
        #end is optional
        if($end)
        {
            $this.end = ConvertTo-NotionFormattedDateTime -InputDate $end -fieldName "end"
        }
    }

    static [notion_date_page_property_structure] ConvertFromObject($Value)
    {
        $date_page_obj = [notion_date_page_property_structure]::new($Value.start, $Value.end)
        return $date_page_obj
    }
}
class notion_date_page_property : PagePropertiesBase
{
    # https://developers.notion.com/reference/page-property-values#date
    [notion_date_page_property_structure] $date

    notion_date_page_property() : base("date")
    {
        $this.date = [notion_date_page_property_structure]::new()
    }

    notion_date_page_property($start, $end) : base("date")
    {
        $this.date = [notion_date_page_property_structure]::new($start, $end)
    }

    static [notion_date_page_property] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_date_page_property]::ConvertFromObject($($Value | ConvertTo-Json -Depth 10))"
        if($Value.date -eq $null)
        {
            return [notion_date_page_property]::new()
        }
        return [notion_date_page_property]::new($Value.date.start, $Value.date.end)
    }
    
}
#EndRegion './Classes/02_Page/PageProperties/05_pp_date.ps1' 54
#Region './Classes/02_Page/PageProperties/07_pp_email.ps1' -1

class notion_email_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#email
{
    [string] $email

    notion_email_page_property($email) : base("email")
    {
        if ($email.Length -gt 200)
        {
            throw [System.ArgumentException]::new("The email must be 200 characters or less.")
        }
        $this.email = $email
    }

    static [notion_email_page_property] ConvertFromObject($Value)
    {
        return [notion_email_page_property]::new($Value.email)
    }
}
#EndRegion './Classes/02_Page/PageProperties/07_pp_email.ps1' 20
#Region './Classes/02_Page/PageProperties/08_pp_files.ps1' -1

class notion_files_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#files
{
    [notion_page_property_type]$type = [notion_page_property_type]::files
    [notion_file[]] $files

    notion_files_page_property([array]$files) : base("files")
    {
        $this.files = $files.ForEach({
            if($_ -is [notion_file])
            {
                $_
            }
            else
            {
                [notion_file]::ConvertFromObject($_)
            }
        })
    }

    static [notion_files_page_property] ConvertFromObject($Value)
    {
        return [notion_files_page_property]::new($Value.files)
    }
}
#EndRegion './Classes/02_Page/PageProperties/08_pp_files.ps1' 26
#Region './Classes/02_Page/PageProperties/09_pp_formula.ps1' -1

class notion_formula_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#formula
{
    [notion_formula] $formula

    notion_formula_page_property() : base("formula")
    {
    }

    notion_formula_page_property([notion_formula]$formula) : base("formula")
    {
        $this.formula = $formula
    }

    static [notion_formula_page_property] ConvertFromObject($Value)
    {
        $formula_obj = [notion_formula_page_property]::new()
        $formula_obj.formula = [notion_formula]::ConvertFromObject($Value.formula)
        return $formula_obj
    }
}
#EndRegion './Classes/02_Page/PageProperties/09_pp_formula.ps1' 22
#Region './Classes/02_Page/PageProperties/10_pp_last_edited_by.ps1' -1

class notion_last_edited_by_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#last-edited-by
{
    [notion_user] $last_edited_by

    notion_last_edited_by_page_property($value) : base("last_edited_by")
    {
        if($value -eq $null)
        {
            $this.last_edited_by = $null
            return
        }
        if($value -is [notion_user])
        {
            $this.last_edited_by = $value
        }
        else{
            $this.last_edited_by = [notion_user]::ConvertFromObject($value)
        }
    }

    static [notion_last_edited_by_page_property] ConvertFromObject($Value)
    {
        return [notion_last_edited_by_page_property]::new($Value.last_edited_by)
    }
}
#EndRegion './Classes/02_Page/PageProperties/10_pp_last_edited_by.ps1' 27
#Region './Classes/02_Page/PageProperties/11_pp_last_edited_time.ps1' -1

class notion_last_edited_time_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#last-edited-time
{
    [string] $last_edited_time

    notion_last_edited_time_page_property($value) : base("last_edited_time")
    {
        $this.last_edited_time = ConvertTo-NotionFormattedDateTime -InputDate $value -fieldName "last_edited_time"
    }

    static [notion_last_edited_time_page_property] ConvertFromObject($Value)
    {
        return [notion_last_edited_time_page_property]::new($Value.last_edited_time)
    }
}
#EndRegion './Classes/02_Page/PageProperties/11_pp_last_edited_time.ps1' 16
#Region './Classes/02_Page/PageProperties/12_pp_multi_select.ps1' -1

class notion_multi_select_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#multi-select
{
    [notion_multi_select_item[]] $multi_select

    notion_multi_select_page_property() : base("multi_select")
    {
        $this.multi_select = @()
    }

    notion_multi_select_page_property($color, $name) : base("multi_select")
    {
        $this.multi_select = @([notion_multi_select_item]::new($color, $name))
    }

    add($color, $name)
    {
        if ($this.multi_select.Count -ge 100)
        {
            throw [System.ArgumentException]::new("The multi_select property must have 100 items or less.")
        }
        $this.multi_select += [notion_multi_select_item]::new($color, $name)
    }

    static [notion_multi_select_page_property] ConvertFromObject($Value)
    {
        $multi_select_obj = [notion_multi_select_page_property]::new()
        # the API reference says its in $Value.multi_select.options but it's actually in $Value.multi_select
        $multi_select_obj.multi_select = $Value.multi_select.foreach{
            [notion_multi_select_item]::ConvertFromObject($_)
        }
        return $multi_select_obj
    }
}
#EndRegion './Classes/02_Page/PageProperties/12_pp_multi_select.ps1' 35
#Region './Classes/02_Page/PageProperties/13_pp_number.ps1' -1

class notion_number_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#number
{
    [double] $number

    notion_number_page_property($number) : base("number")
    {
        $this.number = [double]$number
    }

    static [notion_number_page_property] ConvertFromObject($Value)
    {
        return [notion_number_page_property]::new($Value.number)
    }
}
#EndRegion './Classes/02_Page/PageProperties/13_pp_number.ps1' 16
#Region './Classes/02_Page/PageProperties/14_pp_people.ps1' -1

class notion_people_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#people
{
    [notion_people_user[]] $people

    notion_people_page_property([object[]]$people) : base("people")
    {
        foreach($person in $people)
        {
            if($person -is [notion_people_user])
            {
                $this.people += $person
            }
            else{
                $this.people += [notion_people_user]::ConvertFromObject($person)
            }
        }
    }

    static [notion_people_page_property] ConvertFromObject($Value)
    {
        return [notion_people_page_property]::new($Value.people)
    }
}
#EndRegion './Classes/02_Page/PageProperties/14_pp_people.ps1' 25
#Region './Classes/02_Page/PageProperties/15_pp_phone_number.ps1' -1

class notion_phone_number_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#phone-number
{
    [string] $phone_number

    notion_phone_number_page_property($phone_number) : base("phone_number")
    {
        if ($phone_number.Length -gt 200)
        {
            throw [System.ArgumentException]::new("The phone number must be 200 characters or less.")
        }
        $this.phone_number = $phone_number
    }

    static [notion_phone_number_page_property] ConvertFromObject($Value)
    {
        return [notion_phone_number_page_property]::new($Value.phone_number)
    }   
}
#EndRegion './Classes/02_Page/PageProperties/15_pp_phone_number.ps1' 20
#Region './Classes/02_Page/PageProperties/16_pp_relation.ps1' -1

class notion_relation_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#relation
{
    [bool] $has_more        # If a relation has more than 25 references, then the has_more value for the relation in the response object is true. If a relation doesn’t exceed the limit, then has_more is false.
    [notion_page_reference[]] $relation


    #TODO Stimmt das so?
    notion_relation_page_property($relation) : base("relation")
    {
        $this.relation = @()
        $this.has_more = $false
        $counter = 0
        foreach ($relation_item in $relation)
        {
            $this.relation += [notion_relation_page_property]::ConvertFromObject($relation_item)
            $counter++
            if ($counter -gt 25 )
            {
                $this.has_more = $true
            }
        }     
    }

    notion_relation_page_property($relation, $has_more) : base("relation")
    {
        $this.relation = @()
        $this.has_more = $has_more
        foreach ($relation_item in $relation)
        {
            $this.relation += [notion_page_reference]::ConvertFromObject($relation_item)
        }     
    }

    #TODO: Limit to max 100 releations
    # https://developers.notion.com/reference/request-limits#limits-for-property-values

    static [notion_relation_page_property] ConvertFromObject($Value)
    {
        return [notion_relation_page_property]::new($Value.relation, $Value.has_more)
    }
}
#EndRegion './Classes/02_Page/PageProperties/16_pp_relation.ps1' 43
#Region './Classes/02_Page/PageProperties/17_pp_rollup.ps1' -1

class notion_rollup_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#rollup
{
    [notion_rollup] $rollup

    notion_rollup_page_property() : base("rollup")
    {
        $this.rollup = [notion_rollup]::new()
    }

    notion_rollup_page_property($type_value, $function, $type) : base("rollup")
    {
        $this.rollup = [notion_rollup]::new($type_value, $function, $type)
    }

    static [notion_rollup_page_property] ConvertFromObject($Value)
    {
        $rollup_obj = [notion_rollup_page_property]::new()
        $rollup_obj.rollup = [notion_rollup]::ConvertFromObject($Value.rollup)
        return $rollup_obj
    }
}
#EndRegion './Classes/02_Page/PageProperties/17_pp_rollup.ps1' 23
#Region './Classes/02_Page/PageProperties/18_pp_rich_text.ps1' -1

class notion_rich_text_page_property : PagePropertiesBase
{
    # $type = "rich_text"
    [rich_text[]] $rich_text
    
    notion_rich_text_page_property([object[]]$text) : base("rich_text")
    {
        $this.rich_text = @()
        foreach ($t in $text)
        {
            if($t -is [rich_text])
            {
                $this.rich_text += $t
            }
            else
            {
                $this.rich_text += [rich_text]::ConvertFromObject($t)
            }
        }
    }

    add($text)
    {
        $this.rich_text += [rich_text]::new($text)
    }

    static [notion_rich_text_page_property] ConvertFromObject($Value)
    {
        return [notion_rich_text_page_property]::new($Value.rich_text)
    }
}
#EndRegion './Classes/02_Page/PageProperties/18_pp_rich_text.ps1' 32
#Region './Classes/02_Page/PageProperties/19_pp_select.ps1' -1


class notion_select_page_property : PagePropertiesBase {
    # https://developers.notion.com/reference/page-property-values#select
    [notion_select] $select

    notion_select_page_property() : base("select")
    {
        $this.select = [notion_select]::new()
    }

    notion_select_page_property($color, $id, $name) : base("select")
    {
        $this.select = [notion_select]::new($color, $id, $name)
    }

    static [notion_select_page_property] ConvertFromObject($Value)
    {
        return [notion_select_page_property]::new($Value.select.color, $Value.select.id, $Value.select.name)
    }
}
#EndRegion './Classes/02_Page/PageProperties/19_pp_select.ps1' 21
#Region './Classes/02_Page/PageProperties/20_pp_status.ps1' -1

class notion_status_page_property : PagePropertiesBase{
    [notion_status] $status

    notion_status_page_property() : base("status")
    {
        $this.status = [notion_status]::new()
    }

    notion_status_page_property($name) : base("status")
    {
        $this.status = [notion_status]::new($name)
    }
    
    notion_status_page_property($color, $name) : base("status")
    {
        $this.status = [notion_status]::new($color, $name)
    }

    notion_status_page_property($color, $id, $name) : base("status")
    {
        $this.status = [notion_status]::new($color, $id, $name)
    }

    static [notion_status_page_property] ConvertFromObject($Value)
    {
        return [notion_status_page_property]::new($Value.status.color, $Value.status.id, $Value.status.name)
    }
}
#EndRegion './Classes/02_Page/PageProperties/20_pp_status.ps1' 29
#Region './Classes/02_Page/PageProperties/21_pp_title.ps1' -1

class notion_title_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#title
{
    [rich_text[]] $title

    notion_title_page_property() : base("title")
    {
        $this.title = @()
    }

    # Constructor
    notion_title_page_property([object]$value) : base("title")
    {
        $this.title = @()
        if($value -is [array])
        {
            foreach($item in $value)
            {
                if($item -is [rich_text])
                {
                    $this.title += $item
                }
                else
                {
                    if($value -is [string])
                    {
                        $this.title += [rich_text_text]::new($value)
                    }
                    else
                    {
                        $this.title += [rich_text]::ConvertFromObject($value)
                    }
                }
            }
        }
        else
        {
            if($value -is [rich_text])
            {
                $this.title += $value
            }
            else
            {
                if($value -is [string])
                {
                    $this.title += [rich_text_text]::new($value)
                }
                else
                {
                    $this.title += [rich_text]::ConvertFromObject($value)
                }
            }
        }
        
        
    }
    #Methods
    add($value)
    {
        $this.title += [rich_text]::new("text", $null, $Value)
    }

    #TODO Array of rich_text?
    static [notion_title_page_property] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_title_page_property]::ConvertFromObject($($Value | ConvertTo-Json -Depth 10))"
        return [notion_title_page_property]::new($Value.title)
    }
}
#EndRegion './Classes/02_Page/PageProperties/21_pp_title.ps1' 70
#Region './Classes/02_Page/PageProperties/22_pp_url.ps1' -1

class notion_url_page_property : PagePropertiesBase
# https://developers.notion.com/reference/page-property-values#url
{
    [string] $url

    notion_url_page_property($url) : base("url")
    {
        $this.url = $url
    }

    static [notion_url_page_property] ConvertFromObject($Value)
    {
        return [notion_url_page_property]::new($Value.url)
    }
}
#EndRegion './Classes/02_Page/PageProperties/22_pp_url.ps1' 16
#Region './Classes/02_Page/PageProperties/23_pp_unique_id.ps1' -1

class notion_unique_id
# https://developers.notion.com/reference/page-property-values#unique-id
{
    [int] $number
    [string] $prefix = $null

    notion_unique_id()
    {
        $this.number = 0
    }

    notion_unique_id($number)
    {
        $this.number = $number
    }
    
    notion_unique_id($number, $prefix)
    {
        $this.number = $number
        $this.prefix = $prefix
    }

    static [notion_unique_id] ConvertFromObject($Value)
    {
        return [notion_unique_id]::new($Value.number, $Value.prefix)
    }
}

class notion_unique_id_page_property : PagePropertiesBase{
    [notion_unique_id] $unique_id

    notion_unique_id_page_property() : base("unique_id")
    {
        $this.unique_id = [notion_unique_id]::new()
    }

    notion_unique_id_page_property($number) : base("unique_id")
    {
        $this.unique_id = [notion_unique_id]::new($number)
    }

    notion_unique_id_page_property($number, $prefix) : base("unique_id")
    {
        $this.unique_id = [notion_unique_id]::new($number, $prefix)
    }

    static [notion_unique_id_page_property] ConvertFromObject($Value)
    {
        return [notion_unique_id_page_property]::new($Value.unique_id.number, $Value.unique_id.prefix)
    }
}
#EndRegion './Classes/02_Page/PageProperties/23_pp_unique_id.ps1' 52
#Region './Classes/02_Page/PageProperties/24_pp_verification.ps1' -1

class notion_verification
# https://developers.notion.com/reference/page-property-values#verification
{
    [notion_page_verification_state] $state
    [notion_user] $verified_by
    [string] $date

    #Constructors
    notion_verification_page_property($Value)
    {
        $this.state = [Enum]::Parse([notion_page_verification_state], $Value.state)
        $this.verified_by = [notion_user]::new($Value.verified_by)
        $this.date = Get-Date $Value.date -Format "yyyy-MM-ddTHH:mm:ss.fffZ"
    }

    notion_verification_page_property($state, $verified_by, $date)
    {
        $this.state = [Enum]::Parse([notion_page_verification_state], $state)
        $this.verified_by = [notion_user]::new($verified_by)
        $this.date = Get-Date $date -Format "yyyy-MM-ddTHH:mm:ss.fffZ"
    }

    #Methods
    static [notion_verification_page_property] ConvertFromObject($Value)
    {
        return [notion_verification_page_property]::new($Value.state, $Value.verified_by, $Value.date)
    }
}

class notion_verification_page_property : PagePropertiesBase{
    [notion_verification] $verification

    notion_verification_page_property() : base("verification")
    {
        $this.verification = [notion_verification]::new()
    }

    notion_verification_page_property($state, $verified_by, $date) : base("verification")
    {
        $this.verification = [notion_verification]::new($state, $verified_by, $date)
    }

    static [notion_verification_page_property] ConvertFromObject($Value)
    {
        return [notion_verification_page_property]::new($Value.verification.state, $Value.verification.verified_by, $Value.verification.date)
    }
}
#EndRegion './Classes/02_Page/PageProperties/24_pp_verification.ps1' 48
#Region './Classes/03_File/01_notion_file.ps1' -1




class notion_file : notion_icon
# https://developers.notion.com/reference/file-object
# https://developers.notion.com/reference/block#file
{
    [notion_filetype]$type
    #caption and name are only used in block/file
    [rich_text[]] $caption = @()
    [string] $name


    notion_file([notion_filetype]$type)
    {
        $this.type = $type
    }

    notion_file([notion_filetype]$type, [string]$name)
    {
        $this.type = $type
        $this.name = $name
    }

    #string caption (optional)
    notion_file([notion_filetype]$type, [string]$name, [string]$caption = "")
    {
        $this.type = $type
        $this.name = $name
        if([string]::IsNullOrEmpty($caption) -eq $false)
        {
            $this.caption = @([rich_text_text]::new($caption))
        }
    }

    notion_file([notion_filetype]$type, [string]$name, [object[]] $caption)
    {
        Write-Verbose "[notion_file]::new($type, $name, $($caption | ConvertTo-Json))"
        $this.type = $type
        $this.name = $name
        $this.caption = @()
        foreach($item in $caption)
        {
            if($item -is [string])
            {
                $this.caption += [rich_text_text]::new($item)
            }
            elseif($item -is [rich_text])
            {
                $this.caption += $item
            }
            else
            {
                $this.caption += [rich_text]::ConvertFromObject($item)
            }
        }
    }


    static [notion_file] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_file]::ConvertFromObject($($Value | ConvertTo-Json))"
        if($null -eq $Value)
        {
            return $null
        }
        $fileObject = $null
        if ($Value.type -eq "file")
        {
            $fileObject = [notion_hosted_file]::ConvertFromObject($Value)
        }
        else
        {
            $fileObject = [notion_external_file]::ConvertFromObject($Value)
        }
        $fileObject.type = $Value.type
        $fileObject.caption = $Value.caption.ForEach({[rich_text]::ConvertFromObject($_)})
        $fileObject.name = $Value.name
        return $fileObject
    }
}
#EndRegion './Classes/03_File/01_notion_file.ps1' 82
#Region './Classes/03_File/02_notion_hosted_file.ps1' -1

class notion_hosted_file_structure
# https://developers.notion.com/reference/file-object#notion-hosted-files
{
    [string]$url
    [string]$expiry_time

    notion_hosted_file_structure()
    {
    }

    notion_hosted_file_structure([string]$url, $expiry_time)
    {
        $this.url = $url
        $this.expiry_time = ConvertTo-NotionFormattedDateTime -InputDate $expiry_time -fieldName "expiry_time"
    }

    notion_hosted_file_structure([System.Object]$Value)
    {
        $this.url = $Value.url
        $this.expiry_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.expiry_time -fieldName "expiry_time"
    }

    static [notion_hosted_file_structure] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_hosted_file_structure]::ConvertFromObject($($Value | ConvertTo-Json))"
        return [notion_hosted_file_structure]::new($Value.url, $Value.expiry_time)
    }
}

class notion_hosted_file : notion_file
{
    [notion_hosted_file_structure]$file

    notion_hosted_file():base("file")
    {
    }

    notion_hosted_file([string]$name, [string]$caption="",[string]$url, $expiry_time):base("file", $name, $caption)
    {
        Write-Verbose "[notion_hosted_file]::new($name, $caption, $url, $expiry_time)"
        $this.file = [notion_hosted_file_structure]::new($url, $expiry_time)
    }

    notion_hosted_file([string]$name, [object[]]$caption, [string]$url, $expiry_time):base("file", $name, $caption)
    {
        Write-Verbose "[notion_hosted_file]::new($name, $($caption | ConvertTo-Json), $url, $expiry_time)"
        $this.file = [notion_hosted_file_structure]::new($url, $expiry_time)
    }

    static [notion_hosted_file] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_hosted_file]::ConvertFromObject($($Value | ConvertTo-Json))"
        $notion_file_obj = [notion_hosted_file]::new()
        $notion_file_obj.file = [notion_hosted_file_structure]::ConvertFromObject($Value.file)
        $notion_file_obj.type = $Value.type
        $notion_file_obj.caption = $Value.caption.ForEach({[rich_text]::ConvertFromObject($_)})
        $notion_file_obj.name = $Value.name
        return $notion_file_obj
    }
}
#EndRegion './Classes/03_File/02_notion_hosted_file.ps1' 61
#Region './Classes/03_File/03_external_file.ps1' -1

class notion_external_file_structure
# https://developers.notion.com/reference/file-object#external-files
{
    [string] $url

    # [notion_external_file]::new("http://..")
    notion_external_file_structure([string]$url)
    {
        $this.url = $url
    }

    static [notion_external_file_structure] ConvertFromObject($Value)
    {        
        Write-Verbose "[notion_external_file_structure]::ConvertFromObject($($Value | ConvertTo-Json))"
        return [notion_external_file_structure]::new($Value.url)
    }
}

class notion_external_file : notion_file
{
    [notion_external_file_structure] $external

    notion_external_file():base("external")
    {
    }
    notion_external_file([string]$name, [string]$caption="",[string]$url):base("external", $name, $caption)
    {
        $this.external = [notion_external_file_structure]::new($url)
    }
    notion_external_file([string]$name, [rich_text[]]$caption, [string]$url):base("external", $name, $caption)
    {
        $this.external = [notion_external_file_structure]::new($url)
    }


    static [notion_external_file] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_external_file]::ConvertFromObject($($Value | ConvertTo-Json))"
        $notionFileOb = [notion_external_file]::new()
        $notionFileOb.external = [notion_external_file_structure]::ConvertFromObject($Value.external)
        $notionFileOb.type = $Value.type
        $notionFileOb.caption = $Value.caption.ForEach({[rich_text]::ConvertFromObject($_)})
        $notionFileOb.name = $Value.name
        return $notionFileOb
    }
}
#EndRegion './Classes/03_File/03_external_file.ps1' 47
#Region './Classes/Block/04_Block.ps1' -1

class notion_block
# https://developers.notion.com/reference/block
{
    $object = "block"
    $id = $null
    $parent = $null
    #$after = ""
    $children = @()
    [string]$created_time
    [notion_user]$created_by
    [string]$last_edited_time
    [notion_user]$last_edited_by
    [bool]$archived = $false
    [bool]$in_trash = $false
    [bool]$has_children = $false

    
    notion_block()
    {
        #$this.id = [guid]::NewGuid().ToString()
        $this.last_edited_time = [datetime]::Now.ToString("yyyy-MM-ddTHH:mm:ssZ")
        $this.created_time = $this.last_edited_time
    }

    # Block with array of children
    # [notion_block]::new(@($block1,$block2))
    notion_block([array] $children)
    {
        #$this.id = [guid]::NewGuid().ToString()
        $this.children = $children
        if ($children.count -gt 0)
        {
            $this.has_children = $true
        }
    }
    # Block with array of children and parent id
    # [notion_block]::new(@($block1,$block2), $parent)
    notion_block([array] $children, [string] $parent)
    {
        #$this.id = [guid]::NewGuid().ToString()
        $this.children = $children
        $this.parent = @{
            "type"     = "block_id"
            "block_id" = $parent
        }
        if ($children.count -gt 0)
        {
            $this.has_children = $true
        }
    }
    addChild($child, [string] $type)
    {
        $out = $child
        if ($child.type)
        {
            $out = $out | Select-Object -ExcludeProperty "type"
        }
        $this.children += @{
            "type"  = $type
            "$type" = $out
        }
        $this.has_children = $true
    }
    addChild($child)
    {
        $out = $child
        $type = $child.type
        # remove type propety from child object
        if ($child.type)
        {
            $out = $out | Select-Object -ExcludeProperty "type"
        }
        $this.children += @{
            "type"  = $type
            "$type" = $out
        }
    }

    static [notion_block] ConvertFromObject($Value)
    {
        # Write-Verbose "[notion_block]::ConvertFromObject($($Value | ConvertTo-Json -Depth 10 ))"
        $notion_block = $null
        switch ($Value.type)
        # https://developers.notion.com/reference/block#block-type-objects
        {
            "bookmark"
            {
                $notion_block = [notion_bookmark_block]::ConvertfromObject($value)
                break
            }
            "breadcrumb"
            {
                $notion_block = [notion_breadcrumb_block]::ConvertfromObject($value)
                break
            }
            "bulleted_list_item"
            {
                $notion_block = [notion_bulleted_list_item_block]::ConvertfromObject($value)
                break
            }
            "callout"
            {
                $notion_block = [notion_callout_block]::ConvertfromObject($value)
                break
            }
            "child_database"
            {
                $notion_block = [notion_child_database_block]::ConvertfromObject($value)
                break
            }
            "child_page"
            {
                $notion_block = [notion_child_page_block]::ConvertfromObject($value)
                break
            }
            "code"
            {
                $notion_block = [notion_code_block]::ConvertfromObject($value)
                break
            }
            "column"
            {
                $notion_block = [notion_column_block]::ConvertfromObject($value)
                break
            }
            "column_list"
            {
                $notion_block = [notion_column_list_block]::ConvertfromObject($value)
                break
            }
            "divider"
            {
                $notion_block = [notion_divider_block]::ConvertfromObject($value)
                break
            }
            "embed"
            {
                $notion_block = [notion_embed_block]::ConvertfromObject($value)
                break
            }
            "equation"
            {
                $notion_block = [notion_equation_block]::ConvertfromObject($value)
                break
            }
            "file"
            {
                $notion_block = [notion_file_block]::ConvertfromObject($value)
                break
            }
            "heading_1"
            {
                $notion_block = [heading]::ConvertfromObject($value)
                break
            }
            "heading_2"
            {
                $notion_block = [heading]::ConvertfromObject($value)
                break
            }
            "heading_3"
            {
                $notion_block = [heading]::ConvertfromObject($value)
                break
            }
            "image"
            {
                $notion_block = [notion_image_block]::ConvertfromObject($value)
                break
            }
            "link_preview"
            {
                $notion_block = [notion_link_preview_block]::ConvertfromObject($value)
                break
            }
            #Mention ??
            "mention"
            {
                # $notion_block = [??]
            }

            "numbered_list_item"
            {
                $notion_block = [notion_numbered_list_item_block]::ConvertfromObject($value)
                break
            }
            "paragraph"
            {
                $notion_block = [notion_paragraph_block]::ConvertfromObject($value)
                break
            }
            "pdf"
            {
                $notion_block = [notion_pdf_block]::ConvertfromObject($value)
                break
            }
            "quote"
            {
                $notion_block = [notion_quote_block]::ConvertfromObject($value)
                break
            }
            "synced_block"
            {
                $notion_block = [notion_synced_block]::ConvertfromObject($value)
                break
            }
            "table"
            {
                $notion_block = [table]::ConvertfromObject($value) 
                break
            }
            # "table_row"
            # {
            # $notion_block = [table_row]::ConvertfromObject($value.table_row)
            # break
            # }
            "table_of_contents"
            {
                $notion_block = [notion_table_of_contents_block]::ConvertfromObject($value)
                break
            }
            "template"
            {
                Write-Error "Block type $($Value.type) is not supported anymore since 27.03.2023" -Category NotImplemented
                break
            }
            "to_do"
            {
                $notion_block = [notion_to_do_block]::ConvertfromObject($value)
                break
            }
            "toggle"
            {
                $notion_block = [notion_toggle_block]::ConvertfromObject($value)
                break
            }
            # "unsupported"
            # {
            # $notion_block = [unsupported]::ConvertfromObject($value.unsupported)
            # break
            # }
            "video"
            {
                $notion_block = [notion_video_block]::ConvertfromObject($value)
                break
            }
            Default
            {
                $type = $null
                if ([System.Enum]::TryParse([notion_blocktype], $Value.type, [ref]$type))
                {
                    Write-Error "Block type $($Value.type) not implemented yet" -Category NotImplemented -RecommendedAction "Please create a Github issue to request this feature"
                }
                else
                {
                    Write-Error "Unknown block type: $($Value.type)" -Category InvalidData -TargetObject $Value -RecommendedAction "Please provide a valid block type"
                }
            }
        
        }
        $notion_block.id = $Value.id
        #TODO: real parent object
        $notion_block.parent = [notion_parent]::ConvertFromObject($Value.parent)
        if($Value.created_time){
            $notion_block.created_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.created_time -fieldName "created_time"
        }
        $notion_block.created_by = [notion_user]::ConvertFromObject($Value.created_by)
        if($value.last_edited_time){
            $notion_block.last_edited_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.last_edited_time -fieldName "last_edited_time"
        }
        $notion_block.last_edited_by = [notion_user]::ConvertFromObject($Value.last_edited_by)
        $notion_block.archived = $Value.archived
        $notion_block.in_trash = $Value.in_trash
        $notion_block.has_children = $Value.has_children
        return $notion_block
    }
}
#EndRegion './Classes/Block/04_Block.ps1' 278
#Region './Classes/Block/05_Bookmark.ps1' -1

class bookmark_structure
{
    [notion_blocktype] $type = "bookmark"
    [rich_text[]] $caption = @()
    [string] $url = $null

    bookmark_structure([string] $url)
    {
        $this.url = $url
    }
    
    
    bookmark_structure([object]$bookmark)
    {
        $this.caption = $bookmark.caption
        $this.url = $bookmark.url
    }


    bookmark_structure([rich_text[]]$caption, [string]$url)
    {
        $this.caption = $caption
        $this.url = $url
    }

    bookmark_structure([string]$caption, [string]$url)
    {
        $this.caption = @([rich_text_text]::new($caption))
        $this.url = $url
    }
}


class notion_bookmark_block : notion_block
# https://developers.notion.com/reference/block#bookmark
{
    [notion_blocktype] $type = "bookmark"
    [bookmark_structure] $bookmark
    

    notion_bookmark_block([string]$url)
    {
        $this.bookmark = [bookmark_structure]::new($url)
    }
    
    notion_bookmark_block([bookmark_structure]$bookmark)
    {
        $this.bookmark = [bookmark_structure]::new($bookmark)
    }
    
    notion_bookmark_block([rich_text[]]$caption, [string]$url)
    {
        $this.bookmark = [bookmark_structure]::new($caption, $url)
    }

    notion_bookmark_block([string]$caption, [string]$url)
    {
        $this.bookmark = [bookmark_structure]::new($caption, $url)
    }


    static [notion_bookmark_block] ConvertFromObject($Value)
    {
        $bookmark_Obj = [notion_bookmark_block]::new()
        $bookmark_Obj.bookmark = [bookmark_structure]::new($Value.bookmark)
        return $bookmark_Obj
    }
}
#EndRegion './Classes/Block/05_Bookmark.ps1' 69
#Region './Classes/Block/06_Breadcrumb.ps1' -1

class notion_breadcrumb_block : notion_block
# https://developers.notion.com/reference/block#breadcrumb
{
    [notion_blocktype] $type = "breadcrumb"
    [object] $breadcrumb = @{}

    notion_breadcrumb_block()
    {
    }


    static [notion_breadcrumb_block] ConvertFromObject($Value)
    {
        return [notion_breadcrumb_block]::new()
    }
}
#EndRegion './Classes/Block/06_Breadcrumb.ps1' 17
#Region './Classes/Block/07_Bulleted_List_Item.ps1' -1

class bulleted_list_item_structure
{
    [rich_text[]] $rich_text = @()
    [notion_color] $color = "default"
    [notion_block[]] $children = @()

    bulleted_list_item_structure()
    {
    }
    
    bulleted_list_item_structure([object] $bulleted_list_item)
    {
        $this.rich_text = $bulleted_list_item.rich_text
        $this.color = $bulleted_list_item.color
    }

    bulleted_list_item_structure([string] $text, [notion_color] $color = "default")
    {
        $this.rich_text = @([rich_text_text]::new($text))
        $this.color = $color
    }

    bulleted_list_item_structure([rich_text[]] $rich_text, [notion_color] $color = "default")
    {
        $this.rich_text = $rich_text
        $this.color = $color
    }
    static [bulleted_list_item_structure] ConvertFromObject($Value)
    {
        $bulleted_list_item_structure_obj = [bulleted_list_item_structure]::new()
        $bulleted_list_item_structure_obj.rich_text = $Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $bulleted_list_item_structure_obj.color = [Enum]::Parse([notion_color], $Value.color)
        return $bulleted_list_item_structure_obj
    }
}


class notion_bulleted_list_item_block : notion_block
# https://developers.notion.com/reference/block#bulleted-list-item
{
    [notion_blocktype] $type = "bulleted_list_item"
    [bulleted_list_item_structure] $bulleted_list_item

    notion_bulleted_list_item_block()
    { 
        $this.bulleted_list_item = [bulleted_list_item_structure]::new()
    }

    notion_bulleted_list_item_block([string] $text, [notion_color] $color = "default")
    {
        $this.bulleted_list_item = [bulleted_list_item_structure]::new($text, $color)
    }

    notion_bulleted_list_item_block([rich_text[]] $rich_text, [notion_color] $color = "default")
    {
        $this.bulleted_list_item = [bulleted_list_item_structure]::new($rich_text, $color)
    }

    static [notion_bulleted_list_item_block] ConvertFromObject($Value)
    {
        $bulleted_list_item_obj = [notion_bulleted_list_item_block]::new()
        $bulleted_list_item_obj.bulleted_list_item = [bulleted_list_item_structure]::ConvertFromObject($Value.bulleted_list_item)
        return $bulleted_list_item_obj
    }
}
#EndRegion './Classes/Block/07_Bulleted_List_Item.ps1' 66
#Region './Classes/Block/08_Callout.ps1' -1

class callout_structure
{
    [notion_blocktype] $type = "callout"
    [rich_text[]] $rich_text
    # icon: emoji or file
    $icon = [notion_emoji]::new("")
    [notion_color] $color = "default"

    callout_structure()
    {
        $this.rich_text = @([rich_text]::new())
    }

    callout_structure([string] $text)
    {
        $this.rich_text = @([rich_text_text]::new($text))
        $this.icon = [notion_emoji]::new()
        $this.color = [notion_color]::default
    }

    callout_structure([rich_text[]] $rich_text, [string] $icon, [notion_color] $color = [notion_color]::default)
    {
        $this.rich_text = $rich_text.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $this.icon = [notion_emoji]::new($icon)
        $this.color = $color
    }

    callout_structure([rich_text[]] $rich_text, [notion_emoji] $icon, [notion_color] $color = [notion_color]::default)
    {
        $this.rich_text = $rich_text.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $this.icon = $icon
        $this.color = $color
    }

    callout_structure([string] $text, [notion_emoji] $icon, [notion_color] $color = [notion_color]::default)
    {
        $this.rich_text = @([rich_text_text]::new($text))
        $this.icon = $icon
        $this.color = $color
    }

    static [callout_structure] ConvertFromObject($Value)
    {
        $callout_structure = [callout_structure]::new()
        $callout_structure.rich_text = $Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        switch ($Value.psobject.properties)
        {
            "emoji"
            {
                $callout_structure.icon = [notion_emoji]::new($Value.icon.emoji.emoji) 
            }
            "file"
            {
                $callout_structure.icon = [notion_file]::new($Value.icon.external.url) 
            }
        }
        $callout_structure.color = [Enum]::Parse([notion_color], $Value.color)
        return $callout_structure
    }
}
class notion_callout_block : notion_block
# https://developers.notion.com/reference/block#callout
{
    [notion_blocktype] $type = "callout"
    [callout_structure] $callout

    notion_callout_block()
    {
        $this.callout = [callout_structure]::new()
    }

    notion_callout_block([rich_text[]] $rich_text, [string] $icon, [notion_color] $color)
    {
        $this.callout = [callout_structure]::new($rich_text, $icon, $color)
    }

    notion_callout_block([rich_text[]] $rich_text, [notion_emoji] $icon, [notion_color] $color)
    {
        $this.callout = [callout_structure]::new($rich_text, $icon, $color)
    }

    static [notion_callout_block] ConvertFromObject($Value)
    {
        $callout_Obj = [notion_callout_block]::new()
        $callout_Obj.callout = [callout_structure]::ConvertFromObject($Value.callout)
        return $callout_Obj
    }
}
#EndRegion './Classes/Block/08_Callout.ps1' 89
#Region './Classes/Block/09_Child_Database.ps1' -1

class child_database_structure
{
    [string] $title = $null
    
    child_database_structure()
    {
    }

    child_database_structure([string] $title)
    {
        $this.title = $title
    }

    static [child_database_structure] ConvertFromObject($Value)
    {
        $child_database_structure = [child_database_structure]::new()
        $child_database_structure.title = $Value.title
        return $child_database_structure
    }
}
class notion_child_database_block : notion_block
# https://developers.notion.com/reference/block#child-database
{
    [notion_blocktype] $type = "child_database"
    [child_database_structure] $child_database


    #TODO: Creating and updating child_database blocks
    #TODO: To create or update child_database type blocks, use the Create a database and the Update a database endpoints, specifying the ID of the parent page in the parent body param.
    notion_child_database_block()
    {
        $this.child_database = [child_database_structure]::new()
    }

    notion_child_database_block([string] $title)
    {
        $this.child_database = [child_database_structure]::new($title)
    }

    static [notion_child_database_block] ConvertFromObject($Value)
    {
        $child_database_Obj = [notion_child_database_block]::new()
        $child_database_Obj.child_database = [child_database_structure]::new($Value.child_database)
        return $child_database_Obj
    }
}
#EndRegion './Classes/Block/09_Child_Database.ps1' 47
#Region './Classes/Block/10_Child_Page.ps1' -1

class child_page_structure
{
    [string] $title = $null

    child_page_structure()
    {

    }

    child_page_structure([string] $title)
    {
        $this.title = $title
    }

    static [child_page_structure] ConvertFromObject($Value)
    {
        $child_page_structure = [child_page_structure]::new()
        $child_page_structure.title = $Value.title
        return $child_page_structure
    }
}
class notion_child_page_block : notion_block
# https://developers.notion.com/reference/block#child-page
{
    [notion_blocktype] $type = "child_page"
    [child_page_structure] $child_page


    notion_child_page_block()
    {
        $this.child_page = [child_page_structure]::new()
    }

    notion_child_page_block([string] $title)
    {
        $this.child_page = [child_page_structure]::new($title)
    }

    static [notion_child_page_block] ConvertFromObject($Value)
    {
        $child_page_Obj = [notion_child_page_block]::new()
        $child_page_Obj.child_page = [child_page_structure]::new($Value.child_page)
        return $child_page_Obj
    }
}
#EndRegion './Classes/Block/10_Child_Page.ps1' 46
#Region './Classes/Block/11_Code.ps1' -1

class code_structure
{
    #TODO: definition correct?
    [rich_text[]] $caption
    [rich_text[]] $rich_text
    #TODO: make sure this is only modified by the setLanguage method
    [string] $private:language

    code_structure()
    {

    }

    code_structure([string] $text, [string] $language)
    {
        if (-not [code_structure]::IsValidLanguage($language))
        {
            throw "Invalid language: $language"
        }
        $this.caption = [rich_text]::new($text)
        $this.rich_text = [rich_text]::new($text)
        $this.language = $language
    }

    code_structure([string] $text, [string] $language, [notion_color] $color)
    {
        if (-not [code_structure]::IsValidLanguage($language))
        {
            throw "Invalid language: $language"
        }
        $this.caption = [rich_text]::new($text, $color)
        $this.rich_text = [rich_text]::new($text, $color)
        $this.language = $language
    }

    static [bool] IsValidLanguage([string]$language)
    {
        $validLanguages = @(
            "abap", "arduino", "bash", "basic", "c", "clojure", "coffeescript", "c++", "c#", "css", "dart", "diff", 
            "docker", "elixir", "elm", "erlang", "flow", "fortran", "f#", "gherkin", "glsl", "go", "graphql", 
            "groovy", "haskell", "html", "java", "javascript", "json", "julia", "kotlin", "latex", "less", "lisp", 
            "livescript", "lua", "makefile", "markdown", "markup", "matlab", "mermaid", "nix", "objective-c", 
            "ocaml", "pascal", "perl", "php", "plain text", "powershell", "prolog", "protobuf", "python", "r", 
            "reason", "ruby", "rust", "sass", "scala", "scheme", "scss", "shell", "sql", "swift", "typescript", 
            "vb.net", "verilog", "vhdl", "visual basic", "webassembly", "xml", "yaml", "java/c/c++/c#"
        )
        return $validLanguages -contains $language
    }

    [string] getLanguage()
    {
        return $this.language
    }
    
    setLanguage([string] $language)
    {
        if (-not [code_structure]::IsValidLanguage($language))
        {
            throw "Invalid language: $language"
        }
        $this.language = $language
    }

    static [code_structure] ConvertFromObject($Value)
    {
        $code_structure = [code_structure]::new()
        $code_structure.caption = $Value.caption.ForEach({ [rich_text]::ConvertFromObject($_) })
        $code_structure.rich_text = $Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        if (-not [code_structure]::IsValidLanguage($Value.language))
        {
            throw "Invalid language: $($Value.language)"
        }
        $code_structure.language = $Value.language
        return $code_structure
    }
}
class notion_code_block : notion_block
# https://developers.notion.com/reference/block#code
{
    [notion_blocktype] $type = "code"
    [code_structure] $code

    notion_code_block()
    {
        $this.code = [code_structure]::new()
    }

    notion_code_block([string] $text, [string] $language)
    {
        $this.code = [code_structure]::new($text, $language)
    }

    notion_code_block([string] $text, [string] $language, [notion_color] $color)
    {
        $this.code = [code_structure]::new($text, $language, $color)
    }

    [string] getLanguage()
    {
        return $this.code.getLanguage()
    }
    
    setLanguage([string] $language)
    {
        if (-not [code_structure]::IsValidLanguage($language))
        {
            throw "Invalid language: $language"
        }
        $this.code.setLanguage($language)
    }

    static [notion_code_block] ConvertFromObject($Value)
    {
        $code_Obj = [notion_code_block]::new()
        $code_Obj.code = [code_structure]::ConvertFromObject($Value.code)
        return $code_Obj
    }
}
#EndRegion './Classes/Block/11_Code.ps1' 119
#Region './Classes/Block/12_Column.ps1' -1

class notion_column_block : notion_block
# https://developers.notion.com/reference/block#column
{
    [notion_blocktype] $type = "column"
    [object] $column = @{}
    
    notion_column_block()
    { 
    }

    static [notion_column_block] ConvertFromObject($Value)
    {
        $Column_Obj = [notion_column_block]::new()
        $Column_Obj.column = $Value.column
        return $Column_Obj
    }
}
#EndRegion './Classes/Block/12_Column.ps1' 18
#Region './Classes/Block/13_Column_List.ps1' -1

class notion_column_list_block : notion_block
# https://developers.notion.com/reference/block#column-list-and-column
{
    [notion_blocktype] $type = "column_list"
    [notion_column_block[]] $column_list = [notion_column_block[]]@()

    notion_column_list_block()
    {
    }

    column_list([notion_column_list_block] $column_list)
    {
        $this.column_list = $column_list
    }

    add($column)
    {
        $this.column_list += $column
    }
    
    static [notion_column_list_block] ConvertFromObject($Value)
    {
        $column_list_obj = [notion_column_list_block]::new()
        #$column_list_obj.add([notion_column_block]::ConvertFromObject($Value.column_list))
        # actual data is in the children (GET /block/{block_id}/children)
        return $column_list_obj
    }
}
#EndRegion './Classes/Block/13_Column_List.ps1' 29
#Region './Classes/Block/14_Divider.ps1' -1

class notion_divider_block : notion_block
# https://developers.notion.com/reference/block#divider
{
    [notion_blocktype] $type = "divider"
    [object] $divider = @{}

    notion_divider_block()
    {
    }
    
    static [notion_divider_block] ConvertFromObject($Value)
    {
        return [notion_divider_block]::new()
    }
}
#EndRegion './Classes/Block/14_Divider.ps1' 16
#Region './Classes/Block/15_Embed.ps1' -1

class embed_structure
{
    [string] $url = $null
    
    embed_structure()
    {

    }
    embed_structure([string] $url)
    {
        $this.url = $url
    }
    
    static [embed_structure] ConvertFromObject($Value)
    {
        $embed_structure = [embed_structure]::new()
        $embed_structure.url = $Value.url
        return $embed_structure
    }
}
class notion_embed_block : notion_block
# https://developers.notion.com/reference/block#embed
{
    [notion_blocktype] $type = "embed"
    [embed_structure] $embed

    notion_embed_block()
    {
        $this.embed = [embed_structure]::new()
    }
    notion_embed_block([string] $url)
    {
        $this.embed = [embed_structure]::new($url)
    }
    
    static [notion_embed_block] ConvertFromObject($Value)
    {
        $embed_Obj = [notion_embed_block]::new()
        $embed_Obj.embed = [embed_structure]::ConvertFromObject($Value.embed)
        return $embed_Obj
    }
}
#EndRegion './Classes/Block/15_Embed.ps1' 43
#Region './Classes/Block/16_Equation.ps1' -1

class equation_structure
{
    [string] $expression = $null

    equation_structure()
    { 
    }

    equation_structure([string] $expression)
    {
        $this.expression = $expression
    }

    static [equation_structure] ConvertFromObject($Value)
    {
        $equation_structure = [equation_structure]::new()
        $equation_structure.expression = $Value.expression
        return $equation_structure
    }
}
class notion_equation_block : notion_block
# https://developers.notion.com/reference/block#equation
{
    [notion_blocktype] $type = "equation"
    [equation_structure] $equation
    
    equation()
    { 
        $this.equation = [equation_structure]::new()
    }

    equation([string] $expression)
    {
        $this.equation = [equation_structure]::new([string] $expression)
    }
    
    static [notion_equation_block] ConvertFromObject($Value)
    {
        $equation_Obj = [notion_equation_block]::new()
        $equation_Obj.equation = [equation_structure]::ConvertFromObject($Value.equation)
        return $equation_Obj
    }
}
#EndRegion './Classes/Block/16_Equation.ps1' 44
#Region './Classes/Block/17.1_Heading.ps1' -1

class Heading : notion_block
# https://developers.notion.com/reference/block#headings
{
    [int] $level
    [notion_blocktype] $type
    [rich_text[]] $rich_text
    [notion_color] $color = "default"
    [boolean] $is_toggleable
    #BUG children is not working


    # Generates an empty heading block with a specified level
    Heading([int] $level)
    {
        $this.level = $level
        $this.type = "heading_$level"
        $this.is_toggleable = $false
    }

    # Generates a heading block with content and a specified level
    # [Heading]::new(1, "Hallo")
    Heading([int] $level, [string] $text)
    {
        $this.level = $level
        $this.type = "heading_$level"
        $this.is_toggleable = $false
        $this.addRichText($text)
    }

    # Generates a heading block with content and a toggleable option
    # [Heading]::new(1, "Hallo", $true)
    Heading([int] $level, [string] $text, [bool] $is_toggleable)
    {
        $this.level = $level
        $this.type = "heading_$level"
        $this.is_toggleable = $is_toggleable
        $this.addRichText($text)
    }

    # Generates a heading block with content class rich_text and toggleable
    # [Heading]::new(1, [rich_text]::new("Hallo"), $true)
    Heading([int] $level, [rich_text] $content, [bool] $is_toggleable)
    {
        $this.level = $level
        $this.type = "heading_$level"
        $this.is_toggleable = $is_toggleable
        $this.addRichText($content)
    }

    Heading([int] $level, [string] $text, [notion_color] $color)
    {
        $this.level = $level
        $this.type = "heading_$level"
        $this.is_toggleable = $false
        $this.color = $color
        $this.addRichText($text)
    }

    Heading([int] $level, [string] $text, [notion_color] $color, [bool] $is_toggleable)
    {
        $this.level = $level
        $this.type = "heading_$level"
        $this.is_toggleable = $is_toggleable
        $this.color = $color
        $this.addRichText($text)
    }

    [void] addRichText([rich_text] $richtext)
    {
        $this.rich_text += $richtext
    }

    [void] addRichText([string] $text)
    {
        $this.rich_text += [rich_text_text]::new($text)
    }

    [string] ToJson([bool]$compress = $false)
    {
        $json = @{
            type = $this.type
            rich_text = $this.rich_text.ToJson()
            color = $this.color
            is_toggleable = $this.is_toggleable
        }
        return $json | ConvertTo-Json -Compress:$compress -EnumsAsStrings
    }

    static [Heading] ConvertFromObject($Value, $level)
    {
        $local:type = $Value.type
        $heading = [Heading]::new($level)
        $heading.rich_text = $Value."$local:type".rich_text.ForEach({[rich_text]::ConvertFromObject($_)})
        $heading.color = [Enum]::Parse([notion_color], $Value.$local:type.color)
        $heading.is_toggleable = $Value.$local:type.is_toggleable
        return $heading
    }

    static [Heading] ConvertFromObject($Value)
    {
        return [Heading]::ConvertFromObject($Value, $Value.type.split("_")[1])
    }
}
#EndRegion './Classes/Block/17.1_Heading.ps1' 104
#Region './Classes/Block/18_Heading1.ps1' -1

class heading_1 : Heading
# https://developers.notion.com/reference/block#headings
{
    # Generates an empty heading_1 block
    heading_1() : base(1)
    {
    }

    # Generates a heading_1 block with content
    # [heading_1]::new("Hallo")
    heading_1([string] $text) : base(1, [string]$text)
    {
    }

    # Generates a heading_1 block with content and toggleable option
    # [heading_1]::new("Hallo", $true)
    heading_1([string] $text, [bool] $is_toggleable) : base(1, $text, $is_toggleable)
    {
    }

    # Generates a heading_1 block with content class rich_text and toggleable
    # [heading_1]::new([rich_text]::new("Hallo"), $true)
    heading_1([rich_text] $content, [bool] $is_toggleable) : base(1, $content, $is_toggleable)
    {
    }
}
#EndRegion './Classes/Block/18_Heading1.ps1' 27
#Region './Classes/Block/19_Heading2.ps1' -1

class heading_2 : Heading
# https://developers.notion.com/reference/block#headings
{
    # Generates an empty heading_2 block
    heading_2() : base(2)
    {
    }

    # Generates a heading_2 block with content
    # [heading_2]::new("Hallo")
    heading_2([string] $content) : base(2, $content)
    {
    }

    # Generates a heading_2 block with content and toggleable option
    # [heading_2]::new("Hallo", $true)
    heading_2([string] $content, [bool] $is_toggleable) : base(2, $content, $is_toggleable)
    {
    }

    # Generates a heading_2 block with content class rich_text and toggleable
    # [heading_2]::new([rich_text]::new("Hallo"), $true)
    heading_2([rich_text] $content, [bool] $is_toggleable) : base(2, $content, $is_toggleable)
    {
    }
}
#EndRegion './Classes/Block/19_Heading2.ps1' 27
#Region './Classes/Block/20_Heading3.ps1' -1

class heading_3 : Heading
# https://developers.notion.com/reference/block#headings
{
    # Generates an empty heading_3 block
    heading_3() : base(3)
    {
    }

    # Generates a heading_3 block with content
    # [heading_3]::new("Hallo")
    heading_3([string] $content) : base(3, $content)
    {
    }

    # Generates a heading_3 block with content and toggleable option
    # [heading_3]::new("Hallo", $true)
    heading_3([string] $content, [bool] $is_toggleable) : base(3, $content, $is_toggleable)
    {
    }

    # Generates a heading_3 block with content class rich_text and toggleable
    # [heading_3]::new([rich_text]::new("Hallo"), $true)
    heading_3([rich_text] $content, [bool] $is_toggleable) : base(3, $content, $is_toggleable)
    {
    }
}
#EndRegion './Classes/Block/20_Heading3.ps1' 27
#Region './Classes/Block/21_Image.ps1' -1


class Image_structure
{
    [notion_file] $image


    Image_structure([notion_file] $file)
    {
        $this.image = $file
    }

    static [Image_structure] ConvertFromObject($Value)
    {
        return [Image_structure]::new($Value.image)
    }
}
class notion_image_block : notion_file
# https://developers.notion.com/reference/block#image
{
    [notion_blocktype] $type = "image"
    [Image_structure] $image

    notion_image_block([notion_file] $file)
    {
        $this.image = [Image_structure]::new($file)
    }
    
    static [notion_image_block] ConvertFromObject($Value)
    {
        $Image_Obj = [notion_image_block]::new()
        $Image_Obj.image = [Image_structure]::ConvertFromObject($Value.image)
        return $Image_Obj
    }
}
#EndRegion './Classes/Block/21_Image.ps1' 35
#Region './Classes/Block/21_Link_Preview.ps1' -1

class link_preview_structure
{
    [string] $url

    link_preview_structure()
    {
    }

    link_preview_structure($url)
    {
        $this.url = $url
    }

    static [link_preview_structure] ConvertFromObject($value)
    {
        return [link_preview_structure]::new($value.url)
    }
}

class notion_link_preview_block : notion_block
# https://developers.notion.com/reference/block#link-preview
{
    [notion_blocktype] $type = "link_preview"
    [link_preview_structure] $link_preview

    notion_link_preview_block()
    { 
    }

    notion_link_preview_block($url)
    {
        $this.link_preview = [link_preview_structure]::new($url)
    }

    static [notion_link_preview_block] ConvertFromObject ($value)
    {
        $link_preview_obj = [notion_link_preview_block]::new()
        $link_preview_obj.link_preview = [link_preview_structure]::ConvertFromObject($value.link_preview)
        return $link_preview_obj
    }

}
#EndRegion './Classes/Block/21_Link_Preview.ps1' 43
#Region './Classes/Block/22_Numbered_List_Item.ps1' -1

class numbered_list_item_structure
{
    [rich_text[]] $rich_text
    [notion_color] $color = "default"
    # TODO: Add children property

    
    numbered_list_item_structure()
    {
    }

    numbered_list_item_structure([rich_text[]] $rich_text)
    {
        $this.rich_text = $rich_text
    }
    numbered_list_item_structure([rich_text[]] $rich_text, [notion_color] $color)
    {
        $this.rich_text = $rich_text
        $this.color = $color
    }


    static [numbered_list_item_structure] ConvertFromObject($Value)
    {
        $numbered_list_item_structure = [numbered_list_item_structure]::new()
        $numbered_list_item_structure.rich_text = $Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $numbered_list_item_structure.color = [Enum]::Parse([notion_color], ($Value.color ?? "default"))
        return $numbered_list_item_structure
    }
}
class notion_numbered_list_item_block : notion_block
# https://developers.notion.com/reference/block#numbered-list-item
{
    [notion_blocktype] $type = "numbered_list_item"
    [numbered_list_item_structure] $numbered_list_item

    notion_numbered_list_item_block() : base("numbered_list_item")
    {
    }

    notion_numbered_list_item_block([rich_text[]] $rich_text) : base("numbered_list_item")
    {
        $this.numbered_list_item = [numbered_list_item_structure]::new($rich_text)
    }

    static [notion_numbered_list_item_block] ConvertFromObject($Value)
    {
        $numbered_list_item_Obj = [notion_numbered_list_item_block]::new()
        $numbered_list_item_Obj.numbered_list_item = [numbered_list_item_structure]::ConvertFromObject($Value.numbered_list_item)
        return $numbered_list_item_Obj
    }
}
#EndRegion './Classes/Block/22_Numbered_List_Item.ps1' 53
#Region './Classes/Block/23_Paragraph.ps1' -1

class paragraph_structure
{
    [rich_text[]] $rich_text
    [notion_color] $color = "default"
    [notion_block[]] $children = @()
    

    paragraph_structure()
    {
    }

    paragraph_structure([rich_text[]] $rich_text)
    {
        $this.rich_text = $rich_text
    }

    [void] addRichText([rich_text] $richtext)
    {
        $this.rich_text += $richtext
    }

    static [paragraph_structure] ConvertFromObject($Value)
    {
        $Paragraph = [paragraph_structure]::new()
        $Paragraph.rich_text = $Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $Paragraph.color = [Enum]::Parse([notion_color], ($Value.color ?? "default"))
        return $Paragraph
    }
}
class notion_paragraph_block : notion_block
# https://developers.notion.com/reference/block#paragraph
{
    [notion_blocktype] $type = "paragraph"
    [Paragraph_structure] $paragraph

    notion_paragraph_block()
    {
        $this.paragraph = [Paragraph_structure]::new(@())
    }

    notion_paragraph_block([rich_text] $richtext)
    {
        $this.paragraph = [Paragraph_structure]::new(@($richtext))
    }

    [void] addRichText([rich_text] $richtext)
    {
        $this.paragraph = [Paragraph_structure]::addRichText($richtext)
    }

    static [notion_paragraph_block] ConvertFromObject($Value)
    {
        $Paragraph_Obj = [notion_paragraph_block]::new()
        $Paragraph_Obj.paragraph = [Paragraph_structure]::ConvertFromObject($Value.paragraph)
        return $Paragraph_Obj
    }
}
#EndRegion './Classes/Block/23_Paragraph.ps1' 58
#Region './Classes/Block/23.1_File_block.ps1' -1

class notion_file_block : notion_block {
    #https://developers.notion.com/reference/block#file
    [notion_blocktype] $type = "file"
    [notion_file]$file

    notion_file_block()
    {
    }
    
    notion_file_block([string]$name, [string]$caption="",[string]$url, $expiry_time)
    {
        $this.file = [notion_hosted_file]::new($name, $caption, $url, $expiry_time)
    }

    notion_file_block([string]$name, [rich_text[]]$caption, [string]$url, $expiry_time)
    {
        $this.file = [notion_hosted_file]::new($name, $caption, $url, $expiry_time)
    }

    notion_file_block([string]$name, [string]$caption="",[string]$url)
    {
        $this.file = [notion_external_file]::new($name, $caption, $url)
    }

    notion_file_block([string]$name, [rich_text[]]$caption, [string]$url)
    {
        $this.file = [notion_external_file]::new($name, $caption, $url)
    }

    #direct object assignment, expected input is either notion_hosted_file or notion_external_file
    notion_file_block([notion_file]$file)
    {
        $this.file = $file
    }

    static [notion_file_block] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_file_block]::ConvertFromObject($($Value | ConvertTo-Json))"
        return [notion_file]::ConvertFromObject($Value.file)
    }
}
#EndRegion './Classes/Block/23.1_File_block.ps1' 42
#Region './Classes/Block/24_PDF.ps1' -1

class PDF_structure
{
    [rich_text[]] $caption
    [notion_filetype] $type
    
    PDF_structure([notion_file] $file)
    {
        $this.type = $file.type
        $this."$($file.type)" = $file
    }

    PDF_structure([rich_text[]] $caption, [notion_filetype] $file)
    {
        $this.caption = @($caption)
        $this.type = $file.type
        $this."$($file.type)" = $file
    }

    static [PDF_structure] ConvertFromObject($Value)
    {
        return [PDF_structure]::new($Value.caption, $Value.pdf)
    }

}
class notion_PDF_block : notion_file
# https://developers.notion.com/reference/block#pdf
{
    [notion_blocktype] $type = "pdf"
    [PDF_structure] $pdf
    
    notion_PDF_block()   
    {
        $this.pdf = [PDF_structure]::new()
        
    }

    notion_PDF_block([notion_file] $file)
    {
        $this.pdf = [PDF_structure]::new($file)
    }

    notion_PDF_block([rich_text[]] $caption, [notion_file] $file)
    {
        $this.pdf = [PDF_structure]::new($caption, $file)
    }
    # # Notion-hosted files constructor
    # PDF($url, $expiry_time, [rich_text[]] $caption) : base($url, $expiry_time)
    # {
    # $this.caption = $caption
    # }

    # # External files constructor
    # PDF($url) : base($url)
    # {
    # $this.caption = @()
    # }

    # # Generic constructor
    # PDF([notion_filetype] $filetype, $url, $expiry_time, [rich_text[]] $caption) : base($filetype, $url, $expiry_time)
    # {
    # $this.caption = $caption
    # }

    static [notion_PDF_block] ConvertFromObject($Value)
    {
        $PDF_obj = [notion_PDF_block]::new()
        $PDF_obj.pdf = [PDF_structure]::ConvertFromObject($Value.pdf)
        return $PDF_obj
    }
}
#EndRegion './Classes/Block/24_PDF.ps1' 71
#Region './Classes/Block/25_Quote.ps1' -1

class Quote_structure
{
    [rich_text[]] $rich_text
    [notion_color] $color = "default"
    [notion_block[]] $children = @()

    #TODO: Implement addchildren
    Quote_structure([rich_text[]] $rich_text, [notion_color] $color = "default")
    {
        $this.rich_text = @($rich_text)
        $this.color = $color
    }

    static [Quote_structure] ConvertFromObject($Value)
    {
        return [Quote_structure]::new($Value.rich_text.ForEach({[rich_text]::ConvertFromObject($_)}), $Value.color)
    }
}

class notion_quote_block : notion_block
# https://developers.notion.com/reference/block#quote
{
    [notion_blocktype] $type = "quote"
    [Quote_structure] $quote

    notion_quote_block()
    {}

    notion_quote_block([rich_text[]] $rich_text, [notion_color] $color)
    {
        $this.quote = [Quote_structure]::new($rich_text, $color)
    }

    static [notion_quote_block] ConvertFromObject($Value)
    {
        $Quote_Obj = [notion_quote_block]::new()
        $Quote_Obj.quote = [Quote_structure]::ConvertFromObject($Value.quote)
        return $Quote_Obj
    }
}
#EndRegion './Classes/Block/25_Quote.ps1' 41
#Region './Classes/Block/26_Synced_Block.ps1' -1

class Synced_Block_structure
{
    [notion_block] $synced_from = $null
    [notion_block[]] $children = @()
    #TODO: Implement addchildren
    
    Synced_Block_structure()
    {
    }

    Synced_Block_structure([notion_block] $synced_from)
    {
        $this.synced_from = $synced_from
    }
    static [Synced_Block_structure] ConvertFromObject($Value)
    {
        return [Synced_Block_structure]::new($Value.synced_from)
    }
}

class notion_synced_block : notion_block
# https://developers.notion.com/reference/block#synced-block
{
    [notion_blocktype] $type = "synced_block"
    [Synced_Block_structure] $synced_block

    notion_synced_block()
    {
        $this.synced_block = [Synced_Block_structure]::new()
    }

    static [notion_synced_block] ConvertFromObject($Value)
    {
        $synced_block_Obj = [notion_synced_block]::new()
        $synced_block_Obj.synced_block = [Synced_Block_structure]::ConvertFromObject($Value.synced_block)
        return $synced_block_Obj
    }
}
#EndRegion './Classes/Block/26_Synced_Block.ps1' 39
#Region './Classes/Block/27.1_TableCell.ps1' -1

class TableCell
{
    #eigentlich ist es ein rich text object
    [rich_text_type] $type = "text"
    $text = @{
        "content" = ""
        "link"    = $null
    }
    [annotation] $annotations = [annotation]::new()

    # empty tablecell
    TableCell()
    {
        $this.text = @{
            "content" = ""
            "link"    = $null
        }
        $this.annotations = [annotation]::new()
    }

    # tablecell with content
    # [tablecell]::new("Hallo")
    TableCell ([string] $content)
    {
        $this.text = @{
            "content" = $content
            "link"    = $null
        }
        $this.annotations = [annotation]::new()
    }

    # tablecell with content and annotations
    # [tablecell]::new("Hallo", [annotation]::new("bold"))
    TableCell ([string] $content, [annotation] $annotations)
    {
        $this.text = @{
            "content" = $content
            "link"    = $null
        }
        $this.annotations = $annotations
    }
    [string] ToString()
    {
        return $this.text.content
    }
}
# class TableCells : System.Collections.IEnumerable{
# #internal collection
# hidden [System.Collections.ArrayList]$items = @()

# TableCells() {
# $this.items = [System.Collections.ArrayList]::new()
# $defaultDisplayPropertySet = New-Object System.Management.Automation.PSPropertySet('DefaultDisplayPropertySet', [string[]]@('items'))
# $standardMembers = [System.Management.Automation.PSMemberInfo[]]@($defaultDisplayPropertySet)
# $this.psobject.TypeNames.Insert(0, 'TableCells')
# $this.psobject.Members.Add((New-Object System.Management.Automation.PSMemberSet('PSStandardMembers', $standardMembers)))
# }

# # Overloaded AddCell methods
# AddCell() {
# $this.items.Add([TableCell]::new())
# }

# AddCell([string]$cellcontent) {
# $this.items.Add([TableCell]::new($cellcontent))
# }

# AddCell($cellcontent, [annotation]$annotations) {
# $this.items.Add([TableCell]::new($cellcontent, $annotations))
# }

# # GetEnumerator for IEnumerable implementation
# [System.Collections.IEnumerator] GetEnumerator() {
# return $this.items.GetEnumerator()
# }

# }

<#
    NewTable() {
        $this.id = [guid]::NewGuid().ToString()
        $this.type = "table"
        $this.table = [Table]::new()
    }
    #>
#EndRegion './Classes/Block/27.1_TableCell.ps1' 86
#Region './Classes/Block/27.2_TableRow.ps1' -1

class TableRow
{
    $cells = @()

    #OverloadDefinitions
    #new row with 1 cell
    # [tablerow]::new()
    TableRow()
    {

    }
    #new row with array of cells
    # [tablerow]::new( @( [tablecell]::new("a") , [tablecell]::new("b") ) )|convertto-json -EnumsAsStrings -Depth 5

    TableRow ([object] $object)
    {
        # for each property add a cell
        # if not a list
        if ($object -isnot [System.Array])
        {
            foreach ($property in $object.psobject.properties)
            {
                $this.AddCell($property.value)
                Write-Debug "Added cell $($this.cells[0].count) content: $($property.value)"
            }
        }
        else
        {
            Write-Debug "TableData $($object |Out-String )"
            foreach ($item in $object)
            {
                $this.AddCell($item)
                Write-Debug "Added cell $($this.cells[0].count) content: $($item)"
            }
        }
    }
    # Overloaded AddCell methods
    AddCell()
    {
        $this.cells += , ([System.Collections.ArrayList](, ([TableCell]::new())))
    }

    AddCell([string]$cellcontent)
    {
        $this.cells += , ([System.Collections.ArrayList](, ([TableCell]::new($cellcontent))))

    }

    AddCell($cellcontent, [annotation]$annotations)
    {
        $this.cells += , ([System.Collections.ArrayList](, ([TableCell]::new($cellcontent, $annotations))))
    }
}
#EndRegion './Classes/Block/27.2_TableRow.ps1' 54
#Region './Classes/Block/27.99_Table.ps1' -1

class Table_structure
{
    [int] $table_width = $null
    [bool] $has_column_header = $false
    [bool] $has_row_header = $false

    Table_structure()
    {
    }

    Table_structure ([int] $table_width)
    {
        $this.table_width = $table_width
    }

    Table_structure ([int] $table_width, [bool] $has_column_header, [bool] $has_row_header)
    {
        $this.table_width = $table_width
        $this.has_column_header = $has_column_header
        $this.has_row_header = $has_row_header
    }

    Table_structure ([pscustomobject[]] $TableData, [bool] $has_column_header, [bool] $has_row_header)
    {
        $this.table_width = $TableData[0].psobject.properties.name.Count
        $this.has_column_header = $has_column_header
        $this.has_row_header = $has_row_header
    }

    # Table_structure ([int] $table_width, [int] $table_height)
    # {
    # $this.table_width = $table_width
    # }

    # Table_structure ([TableRow[]] $rows, [bool] $has_column_header, [bool] $has_row_header)
    # {
    # }

    static [Table_structure] ConvertFromObject($Value)
    {
        $Table_structure_Obj = [Table_structure]::new()
        $Table_structure_Obj.table_width = $Value.table.table_width
        $Table_structure_Obj.has_column_header = $Value.table.has_column_header
        $Table_structure_Obj.has_row_header = $Value.table.has_row_header
        return $Table_structure_Obj
    }
}
class Table : notion_block
# https://developers.notion.com/reference/block#table
{
    [notion_blocktype] $type = "table"
    [Table_structure] $table

    #Table with 1 row and 1 column
    Table()
    {
        $this.table = [Table_structure]::new()
    }

    #Table with 1 row and $table_width columns
    Table ([int] $table_width)
    {
        $this.table_width = $table_width
        for ($i = 0; $i -lt $table_width; $i++)
        {
            $this.children[0].cells += [TableCell]::new()
        }
    }

    #$NotionTable = [NotionTable]::new($TableData, $has_column_header, $has_row_header)
    Table ([pscustomobject[]] $TableData, [bool] $has_column_header, [bool] $has_row_header)
    {
        $this.table_width = $TableData[0].psobject.properties.name.Count
        $this.has_column_header = $has_column_header
        $this.has_row_header = $has_row_header
        if (($has_row_header -eq $false) -and ($has_column_header -eq $true))
        {
            # add first row with column header
            $this.AddRow([TableRow]::new($TableData[0].psobject.properties.name))
            # add data rows
            for ($i = 0; $i -lt $TableData.Count; $i++)
            {
                $this.AddRow([TableRow]::new($TableData[$i]))
            }
        }
        elseif (($has_row_header -eq $true) -and ($has_column_header -eq $false))
        {
            # rotate table
            $headers = $TableData[0].psobject.properties.name
            $data = @()
            foreach ($header in $headers)
            {
                $data = @()
                $data += $header
                for ($i = 0; $i -lt $TableData.Count; $i++)
                {
                    # select attribute values
                    $data += $TableData."$($header)"
                }
                $this.AddRow([TableRow]::new($data))
            }
        }
        else
        {
            throw "Not implemented"
        }
    }

    #Table with $table_height rows and $table_width columns
    # [table]::new(2,3) => table with 2 rows and 3 empty columns
    #TODO
    Table ([int] $table_width, [int] $table_height)
    {
        $this.table_width = $table_width
        $cells = @()
        for ($i = 0; $i -lt $table_width; $i++)
        {
            $cells += [TableCell]::new()
        }
        Write-Host "Cells :$($cells.count)"
        $this.rows = @()
        for ($i = 0; $i -lt $table_height; $i++)
        {
            $this.rows += [TableRow]::new($cells)
        }
        Write-Host "Rows :$($this.rows.count)"
    }

    #Table with rowarray
    # [table]::new(@([tablerow]::new(),[tablerow]::new()))
    Table ([TableRow[]] $rows)
    {
        $this.children = $rows
    }

    #Table with rowarray and columnheader or rowheader
    # [table]::new(@([tablerow]::new(),[tablerow]::new()), $true, $false)
    Table ([TableRow[]] $rows, [bool] $has_column_header, [bool] $has_row_header)
    {
        $this.children = $rows
        $this.has_column_header = $has_column_header
        $this.has_row_header = $has_row_header
    }

    #adds a row to the table
    # [table]::AddRow([tablerow]::new())
    AddRow ([TableRow] $row)
    {
        $this.children += @{
            "type"      = "table_row"
            "table_row" = $row
        }
    }
    #adds a the array of cells to a new row of the table
    # [table]::AddRow(@([tablecell]::new(),[tablecell]::new()))
    AddRow ([TableCell[]] $cells)
    {
        $this.AddRow([TableRow]::new($cells))
    }

    # enables column header
    # $table.has_column_header()
    #BUG: has_column_header is not working
    has_column_header ()
    {
        $this.has_column_header = $true
    }

    # enables row header
    # $table.has_row_header()
    #BUG: has_row_header is not working
    has_row_header ()
    {
        $this.has_row_header = $true
    }

    # # Aus ShopWare kommt ein Array of CustomObjects
    # static [table] ConvertFromObject($Value)
    # {
    # $table = [table]::new()
    # $table.has_children = $Value.has_children
    # $table.table_width = $Value.table.table_width
    # $table.has_column_header = $Value.table.has_column_header
    # $table.has_row_header = $Value.table.has_row_header
    # $table.id = $Value.id
    # $table.parent = $value.parent
    # $table.created_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.created_time -fieldName "created_time"
    # $table.last_edited_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.last_edited_time -fieldName "last_edited_time"
    # $table.created_by = [notion_user]::ConvertFromObject($Value.created_by)
    # $table.last_edited_by = [notion_user]::ConvertFromObject($Value.last_edited_by)
    # $table.archived = $Value.archived
    # $table.in_trash = $Value.in_trash
    # return $table
    # }
    static [table] ConvertFromObject($Value)
    {
        $Table_Obj = [table]::new()
        $Table_Obj.table = [Table_structure]::ConvertFromObject($Value.table)
        return $Table_Obj
    }
}
#EndRegion './Classes/Block/27.99_Table.ps1' 202
#Region './Classes/Block/30_Table_Of_Contents.ps1' -1

class Table_Of_Contents_structure
{
    [notion_color] $color = "default"

    Table_Of_Contents_structure([notion_color] $color = "default")
    {
        $this.color = $color
    }
    static [Table_Of_Contents_structure] ConvertFromObject($Value)
    {
        return [Table_Of_Contents_structure]::new([Enum]::Parse([notion_color], $Value.color))
    }
}

class notion_table_of_contents_block : notion_block
# https://developers.notion.com/reference/block#table-of-contents
{
    [notion_blocktype] $type = "table_of_contents"
    [Table_Of_Contents_structure] $table_of_contents

    notion_table_of_contents_block([notion_color] $color = "default")
    {
        $this.table_of_contents = [Table_Of_Contents_structure]::new($color)
    }

    static [notion_table_of_contents_block] ConvertFromObject($Value)
    {
        $table_of_contents_Obj = [notion_table_of_contents_block]::new()
        $table_of_contents_Obj.table_of_contents = [Table_Of_Contents_structure]::ConvertFromObject($Value.table_of_contents)
        return $table_of_contents_Obj
    }
}
#EndRegion './Classes/Block/30_Table_Of_Contents.ps1' 33
#Region './Classes/Block/31_To_do.ps1' -1

class notion_to_do
{
    [rich_text[]] $rich_text
    [bool] $checked = $false
    [notion_color] $color = "default"
    [notion_block[]] $children = @()
    # TODO: Implement addchildren

    notion_to_do()
    {
    }

    notion_to_do([rich_text[]] $rich_text, [bool] $checked = $false, [notion_color] $color = "default")
    {
        $this.rich_text = $rich_text.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $this.checked = $checked
        $this.color = $color
    }

    static [notion_to_do] ConvertFromObject ($Value)
    {
        $notion_to_do_obj = [notion_to_do]::new()
        $notion_to_do_obj.rich_text = $Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) })
        $notion_to_do_obj.checked = $Value.checked
        $notion_to_do_obj.color = [Enum]::Parse([notion_color], $Value.color ?? "default")
        return $notion_to_do_obj
    }
}
class notion_to_do_block : notion_block
# https://developers.notion.com/reference/block#to-do
{
    [notion_blocktype] $type = "to_do"
    [notion_to_do] $to_do

    notion_to_do_block() : base("to_do")
    {
    }

    notion_to_do_block([rich_text[]] $rich_text, [bool] $checked = $false, [notion_color] $color = "default") : base("to_do")
    {
        $this.to_do = [notion_to_do]::new($rich_text, $checked, $color)
    }

    static [notion_to_do_block] ConvertFromObject ($Value)
    {
        $To_do_Obj = [notion_to_do_block]::new()
        $To_do_Obj.to_do = [notion_to_do]::ConvertFromObject($Value.to_do)
        return $To_do_Obj
    }
}
#EndRegion './Classes/Block/31_To_do.ps1' 51
#Region './Classes/Block/32_Toggle.ps1' -1

class Toggle_structure
{
    [rich_text[]] $rich_text
    [notion_color] $color = "default"
    [notion_block[]] $children = @()
    #TODO: Implement addchildren

    Toggle_structure([rich_text[]] $rich_text, [notion_color] $color = "default")
    {
        $this.rich_text = @($rich_text)
        $this.color = $color
    }

    static [Toggle_structure] ConvertFromObject($Value)
    {
        return [Toggle_structure]::new($Value.rich_text.ForEach({ [rich_text]::ConvertFromObject($_) }), $Value.color)
    }
}
class notion_toggle_block : notion_block
# https://developers.notion.com/reference/block#toggle-blocks
{
    [notion_blocktype] $type = "toggle"
    [Toggle_structure] $toggle

    notion_toggle_block([rich_text[]] $rich_text, [notion_color] $color = "default")
    {
        $this.toggle = [Toggle_structure]::new($rich_text, $color)
    }

    static [notion_toggle_block] ConvertFromObject($Value)
    {
        $Toggle_Obj = [notion_toggle_block]::new()
        $Toggle_Obj.toggle = [Toggle_structure]::ConvertFromObject($Value.toggle)
        return $Toggle_Obj
    }
}  
#EndRegion './Classes/Block/32_Toggle.ps1' 37
#Region './Classes/Block/33_Video.ps1' -1

class Video_structure : notion_file
# https://developers.notion.com/reference/block#video
{
    Video_structure()
    {
    }

    Video_structure($url) :base($url)
    {
        
    }
    Video_structure($url, $expiry_time) :base($url, $expiry_time)
    {
        
    }
    Video_structure([notion_filetype] $filetype, $url, $expiry_time) :base($filetype, $url, $expiry_time)
    {
        
    }

    static [Video_structure] ConvertFromObject($Value)
    {
        return [notion_file]::ConvertFromObject($Value)
    }
}
class notion_video_block : notion_file
# https://developers.notion.com/reference/block#video
{
    [notion_blocktype] $type = "video"

    notion_video_block()
    {
    }

    Video($url)
    {
        $this.video = [Video_structure]::new($url)
    }

    notion_video_block($url, $expiry_time)
    {
        $this.video = [Video_structure]::new($url, $expiry_time)
    }

    notion_video_block([notion_filetype] $filetype, $url, $expiry_time) :base($filetype, $url, $expiry_time)
    {
        $this.video = [Video_structure]::new($filetype, $url, $expiry_time)
    }

    static [notion_video_block] ConvertFromObject($Value)
    {
        $Video_Obj = [notion_video_block]::new()
        $Video_Obj.video = [Video_structure]::ConvertFromObject($Value.video)
        return $Video_Obj
    }
}
#EndRegion './Classes/Block/33_Video.ps1' 57
#Region './Classes/Block/RichText/01_Rich_Text.ps1' -1

class rich_text
# https://developers.notion.com/reference/rich-text
{
    [rich_text_type] $type
    # object: text / mention / equation
    [annotation] $annotations
    [string] $plain_text = $null
    $href = $null

    # empty rich text object
    # [rich_text]::new()
    rich_text()
    {

    }
    rich_text([string] $type)
    {
        $this.type = [Enum]::Parse([rich_text_type], $type)
    }

    rich_text([rich_text_type] $type)
    {
        $this.type = $type
    }

    # rich text object with content and annotations
    # [rich_text]::new("Hallo", [annotation]::new())
    #BUG ?? sollte das nicht mit test moeglich sein ??
    rich_text([rich_text_type] $type, [annotation] $annotations)
    {
        $this.type = $type
        $this.annotations = $annotations
    }
    rich_text([rich_text_type] $type, [annotation] $annotations, [string] $plain_text)
    {
        if ($plain_text.Length -gt 2000)
        {
            throw [System.ArgumentException]::new("The plain text must be 2000 characters or less.")
        }
        $this.type = $type
        $this.annotations = $annotations
        $this.plain_text = $plain_text
    }
    
    rich_text([rich_text_type] $type, [annotation] $annotations, [string] $plain_text, $href)
    {
        if ($plain_text.Length -gt 2000)
        {
            throw [System.ArgumentException]::new("The plain text must be 2000 characters or less.")
        }
        if ($href.Length -gt 2000)
        {
            throw [System.ArgumentException]::new("The href must be 2000 characters or less.")
        }
        $this.type = $type
        $this.annotations = $annotations
        $this.plain_text = $plain_text
        $this.href = $href
    }


    static [rich_text] ConvertFromObject($Value)
    {
        Write-Verbose "[rich_text]::ConvertFromObject($($Value | ConvertTo-Json))"
        if (!$Value.type)
        {
            return $null
        }
        $rich_text = $null
        switch ($Value.type)
        {
            "text"
            {
                $rich_text = [rich_text_text]::ConvertFromObject($Value)
                break
            }
            "mention"
            {
                $rich_text = [rich_text_mention]::ConvertFromObject($Value)
                break
            }
            "equation"
            {
                $rich_text = [rich_text_equation]::ConvertFromObject($Value)
                break
            }
            default
            {
                Write-Error "Unknown rich text type: $($Value.type)" -Category InvalidData -TargetObject $Value -RecommendedAction "Please provide a valid rich text type (text, mention or equation)"
            }
        }
        $local:annotations = [annotation]::ConvertFromObject($Value.annotations)
        if ($local:annotations)
        {
            $rich_text.annotations = $local:annotations
        }
        $rich_text.plain_text ??= $Value.plain_text
        $rich_text.href = $Value.href
        return $rich_text
    }
}
#EndRegion './Classes/Block/RichText/01_Rich_Text.ps1' 102
#Region './Classes/Block/RichText/02_Rich_Text_Annotation.ps1' -1

class annotation
# https://developers.notion.com/reference/rich-text#the-annotation-object
{
    [bool] $bold = $false
    [bool] $italic = $false
    [bool] $strikethrough = $false
    [bool] $underline = $false
    [bool] $code = $false
    [notion_color] $color = "default"
    annotation()
    {
        
    }
    # annotation with format option
    # [annotation]::new("bold")
    # [annotation]::new(@("bold","code"))
    annotation($annotations)
    {
        if (!$annotations) {
            return
        }
        $this.bold = $annotations.bold
        $this.italic = $annotations.italic
        $this.strikethrough = $annotations.strikethrough
        $this.underline = $annotations.underline
        $this.code = $annotations.code
        $this.color = [Enum]::Parse([notion_color], $annotations.color)
    }
    annotation([bool]$bold,[bool]$italic,[bool]$strikethrough,[bool]$underline,[bool]$code,[notion_color]$color)
    {
        $this.bold = $bold
        $this.italic = $italic
        $this.strikethrough = $strikethrough
        $this.underline = $underline
        $this.code = $code
        $this.color = $color
    }

    [string] ToJson([bool]$compress = $false)
    {
        $json = @{
            bold = $this.bold
            italic = $this.italic
            strikethrough = $this.strikethrough
            underline = $this.underline
            code = $this.code
            color = $this.color.ToString()
        }
        return $json | ConvertTo-Json -Compress:$compress -EnumsAsStrings
    }

    static [annotation] ConvertFromObject($Value)
    {
        Write-Verbose "[annotation]::ConvertFromObject($($Value | ConvertTo-Json))"
        $annotation = [annotation]::new()
        if(!$Value)
        {
            return $null
        }
        $annotation.bold = $Value.bold
        $annotation.italic = $Value.italic
        $annotation.strikethrough = $Value.strikethrough
        $annotation.underline = $Value.underline
        $annotation.code = $Value.code
        $annotation.color = [Enum]::Parse([notion_color], $Value.color)
        return $annotation
    }
}
#EndRegion './Classes/Block/RichText/02_Rich_Text_Annotation.ps1' 69
#Region './Classes/Block/RichText/Type/01_Rich_text_text.ps1' -1

#https://developers.notion.com/reference/rich-text#text
class rich_text_text_structure
{
    [string] $content = ""
    $link

    rich_text_text_structure()
    {
        $this.content = ""
        $this.link = $null
    }
    
    rich_text_text_structure([string]$content )
    {
        $this.content = $content
        $this.link = $null
    }

    
    rich_text_text_structure([string]$content, [string]$link)
    {
        $this.content = $content
        $this.link = $link
    }

    static [rich_text_text_structure] ConvertFromObject($Value)
    {
        $rich_text_text_structure = [rich_text_text_structure]::new()
        $rich_text_text_structure.content = $Value.content
        $rich_text_text_structure.link = $Value.link
        return $rich_text_text_structure
    }
}


class rich_text_text : rich_text
{
    [rich_text_text_structure] $text

    # Default constructor
    rich_text_text() : base("text")
    {
    }
    

    # Constructor with rich_text_text_structure parameter
    rich_text_text($content) : base("text")
    {
        if ($null -eq $content)
        {
            $this.text = [rich_text_text_structure]::new()
            $this.plain_text = ""
        }
        elseif ($content -is [string])
        {
            $this.text = [rich_text_text_structure]::new($content)
            $this.plain_text = $content
        }
        elseif ($content -is [rich_text_text_structure])
        {
            $this.text = $content
            $this.plain_text = $content.content
        }
        else
        {
            $this.text = [rich_text_text_structure]::ConvertFromObject($content)
            $this.plain_text = $content.content
        }
    }

    # Constructor with content string and annotations
    rich_text_text([string] $content, $annotations) : base("text", $annotations)
    {
        $this.text = [rich_text_text_structure]::new($content)
        $this.plain_text = $content
    }

    # Constructor with content string, annotations, and plain_text
    rich_text_text([string] $content, $annotations, $plain_text) : base("text", $annotations, $plain_text)
    {
        $this.text = [rich_text_text_structure]::new($content)
    }

    # [string] ToJson([bool]$compress = $false) {
    # $json = @{
    # type = $this.type
    # text = $this.text.ToJson()
    # annotations = $this.annotations.ToJson()
    # plain_text = $this.plain_text
    # href = $this.href
    # }
    # return $json | ConvertTo-Json -Compress:$compress
    # }

    static [rich_text_text] ConvertFromObject($Value)
    {
        $rich_text = [rich_text_text]::new()
        $rich_text.text = [rich_text_text_structure]::ConvertFromObject($Value.text)
        $rich_text.plain_text = $Value.plain_text ?? $Value.text.content
        return $rich_text
    }
}
#EndRegion './Classes/Block/RichText/Type/01_Rich_text_text.ps1' 103
#Region './Classes/Block/RichText/Type/02_Rich_text_mention.ps1' -1

class rich_text_mention_base
{
    [rich_text_mention_type] $type
    
    rich_text_mention_base()
    {
    }
    rich_text_mention_base([rich_text_mention_type] $type)
    {
        $this.type = $type
    }
}


class rich_text_mention : rich_text
{
    # https://developers.notion.com/reference/rich-text#mention
    [rich_text_mention_base] $mention
    

    rich_text_mention():base("mention")
    {
    }
    rich_text_mention([rich_text_mention_type] $type) :base("mention")
    {
        $this.type = $type

    }

    [string] ToJson([bool]$compress = $false)
    {
        $json = @{
            type = $this.type
        }
        switch ($this.type)
        {
            "database"
            { 
                $json.mention = $this.database.ToJson()
            }
            "date"
            { 
                $json.mention = $this.date.ToJson()
            }
            "link_preview"
            { 
                $json.mention = $this.link_preview.ToJson()
            }
            "page"
            { 
                $json.mention = $this.page.ToJson()
            }
            "template_mention"
            { 
                $json.mention = $this.template_mention.ToJson()
            }
            "user"
            { 
                $json.mention = $this.user.ToJson()
            }
            Default
            {
            }
        }
        $json.annotations = $this.annotations.ToJson()
        $json.plain_text = $this.plain_text
        $json.href = $this.href
        return $json | ConvertTo-Json -Compress:$compress
    }
    
    static [rich_text_mention] ConvertFromObject($Value)
    {
        $rich_text = [rich_text_mention]::New()
        $rich_text.type = $Value.type
        
        switch ($Value.mention.type)
        {
            "database"
            { 
                $rich_text.mention = [rich_text_mention_database]::ConvertFromObject($Value.mention.database)
            }
            "date"
            { 
                $rich_text.mention = [rich_text_mention_date]::ConvertFromObject($Value.mention.date)
            }
            "link_preview"
            { 
                $rich_text.mention = [rich_text_mention_link_preview]::ConvertFromObject($Value.mention.link_preview)
            }
            "page"
            { 
                $rich_text.mention = [rich_text_mention_page]::ConvertFromObject($Value.mention.page)
            }
            "template_mention"
            { 
                $rich_text.mention = [rich_text_mention_template_mention]::ConvertFromObject($Value.mention.template_mention)
            }
            "user"
            { 
                $rich_text.mention = [rich_text_mention_user]::ConvertFromObject($Value.mention.user)
            }
            Default
            {
            }
        }
        return $rich_text
    }
}
#EndRegion './Classes/Block/RichText/Type/02_Rich_text_mention.ps1' 109
#Region './Classes/Block/RichText/Type/03_Rich_text_equation.ps1' -1

class rich_text_equation_structure 
{
    [string] $expression = ""
    
    rich_text_equation_structure()
    {
    }
    
    rich_text_equation_structure($expression)
    {
        $this.expression = $expression
    }
    
    rich_text_equation_structure($expression, $link)
    {
        $this.expression = $expression
    }
    
    static [rich_text_equation_structure] ConvertFromObject($Value)
    {
        $rich_text_equation_structure = [rich_text_equation_structure]::new()
        $rich_text_equation_structure.expression = $Value.expression
        return $rich_text_equation_structure
    }
    
}

class rich_text_equation : rich_text{
# https://developers.notion.com/reference/rich-text#equation
    [rich_text_equation_structure] $equation
    
    rich_text_equation():base("equation")
    {
    }
    
    rich_text_equation([rich_text_equation_structure] $equation) :base("equation")
    {
        $this.equation = $equation
    }
    
    rich_text_equation([string] $content) :base("equation")
    {
        $this.equation = [rich_text_equation_structure]::new($content)
    }

    [string] ToJson([bool]$compress = $false)
    {
        $json = @{
            type = $this.type
            equation = @{
                expression = $this.equation.expression
            }
            annotations = $this.annotations.ToJson()
            plain_text = $this.plain_text
            href = $this.href
        }
        return $json | ConvertTo-Json -Compress:$compress
    }
    
    static [rich_text_equation] ConvertFromObject($Value)
    {
        #TODO: Implement this
        return $null
    }
}
#EndRegion './Classes/Block/RichText/Type/03_Rich_text_equation.ps1' 66
#Region './Classes/Block/RichText/Type/MentionObject/01_rich_text_mention_database.ps1' -1

class rich_text_mention_database_structure
{
    [string] $id = ""

    rich_text_mention_database_structure() 
    {
    }
    rich_text_mention_database_structure($id)
    {
        $this.id = $id
    }

    static [rich_text_mention_database_structure] ConvertFromObject($value)
    {
        [rich_text_mention_database_structure] $struct = [rich_text_mention_database_structure]::new()
        $struct.id = $value.id
        return $struct
    }
}


class rich_text_mention_database : rich_text_mention_base
# https://developers.notion.com/reference/rich-text#mention
{
    [rich_text_mention_database_structure] $database
    

    rich_text_mention_database():base("database")
    {
    }

    rich_text_mention_database([rich_text_mention_database_structure] $database) :base("database")
    {
        $this.database = $database
    }

    rich_text_mention_database([string] $id) :base("database")
    {
        $this.database = [rich_text_mention_database_structure]::new($id)
    }

    [string] ToJson([bool]$compress = $false)
    {
        $json = @{
            type = $this.type
            database = @{
                id = $this.database.id
            }
            annotations = $this.annotations.ToJson()
            plain_text = $this.plain_text
            href = $this.href
        }
        return $json | ConvertTo-Json -Compress:$compress
    }

    static [rich_text_mention_database] ConvertFromObject($value)
    {
        return [rich_text_mention_database]::new($value.database)
    }
}
#EndRegion './Classes/Block/RichText/Type/MentionObject/01_rich_text_mention_database.ps1' 61
#Region './Classes/Block/RichText/Type/MentionObject/02_rich_text_mention_date.ps1' -1

class rich_text_mention_date_structure
{
    [DateTime] $start
    [DateTime] $end

    rich_text_mention_date_structure()
    {
    }
    rich_text_mention_date_structure($start)
    {
        $this.start = $start
    }
    rich_text_mention_date_structure($start, $end)
    {
        $this.start = $start
        $this.end = $end
    }

    static [rich_text_mention_date_structure] ConvertFromObject($value)
    {
        return [rich_text_mention_date_structure]::new($value.start, $value.end)
    }
}


class rich_text_mention_date : rich_text_mention_base
# https://developers.notion.com/reference/rich-text#mention
{
    [rich_text_mention_date_structure] $date
    

    rich_text_mention_date() :base("date")
    {
        
    }

    rich_text_mention_date([rich_text_mention_date_structure] $date) :base("date")
    {
        $this.date = Get-Date $date -Format "yyyy-MM-dd"
    }

    rich_text_mention_date($start) :base("date")
    {
        $this.date = [rich_text_mention_date_structure]::new($start)
    }
    rich_text_mention_date($start, $end) :base("date")
    {
        $this.date = [rich_text_mention_date_structure]::new($start, $end)
    }

    static [rich_text_mention_date] ConvertFromObject($value)
    {
        return [rich_text_mention_date]::new($value.date)
    }
}
#EndRegion './Classes/Block/RichText/Type/MentionObject/02_rich_text_mention_date.ps1' 56
#Region './Classes/Block/RichText/Type/MentionObject/03_rich_text_mention_link_preview.ps1' -1

class rich_text_mention_link_preview : rich_text_mention_base
# https://developers.notion.com/reference/rich-text#mention
{
    [rich_text_mention_type] $type = "link_preview"
    [link_preview_structure] $link_preview
    

    rich_text_mention_link_preview() :base("link_preview")
    {
    }

    rich_text_mention_link_preview([link_preview_structure] $link_preview) :base("link_preview")
    {
        $this.link_preview = $link_preview
    }

    rich_text_mention_link_preview([string] $url) :base("link_preview")
    {
        $this.link_preview = [link_preview_structure]::new($url)
    }

    static [rich_text_mention_link_preview] ConvertFromObject($value)
    {
        return [rich_text_mention_link_preview]::new($value.link_preview)
    }
}
#EndRegion './Classes/Block/RichText/Type/MentionObject/03_rich_text_mention_link_preview.ps1' 27
#Region './Classes/Block/RichText/Type/MentionObject/04_rich_text_mention_page.ps1' -1

class rich_text_mention_page_structure
{
    [string] $id = ""

    rich_text_mention_page_structure() 
    {
    }
    rich_text_mention_page_structure($id)
    {
        $this.id = $id
    }

    static [rich_text_mention_page_structure] ConvertFromObject($value)
    {
        [rich_text_mention_page_structure] $struct = [rich_text_mention_page_structure]::new()
        $struct.id = $value.id
        return $struct
    }
}


class rich_text_mention_page : rich_text_mention_base
# https://developers.notion.com/reference/rich-text#mention
{
    [rich_text_mention_page_structure] $page
    

    rich_text_mention_page():base("page")
    {
    }

    rich_text_mention_page([rich_text_mention_page_structure] $page) :base("page")
    {
        $this.page = $page
    }

    rich_text_mention_page([string] $id) :base("page")
    {
        $this.page = [rich_text_mention_page_structure]::new($id)
    }

    static [rich_text_mention_page] ConvertFromObject($value)
    {
        return [rich_text_mention_page]::new($value.page)
    }
}
#EndRegion './Classes/Block/RichText/Type/MentionObject/04_rich_text_mention_page.ps1' 47
#Region './Classes/Block/RichText/Type/MentionObject/05_rich_text_mention_template_mention.ps1' -1

class rich_text_mention_template_mention_structure_base
{
    [string] $type = "template_mention_date"

}
class rich_text_mention_template_mention_template_mention_date_structure : rich_text_mention_template_mention_structure_base{
    [datetime] $template_mention_date = ""

    rich_text_mention_template_mention_template_mention_date_structure() : base("template_mention_date")
    {
    }
    rich_text_mention_template_mention_template_mention_date_structure([string]$template_mention_date) : base("template_mention_date")
    {
        [datetime]$date = get-date
        if([datetime]::TryParse($template_mention_date, [ref]$date)){
            $this.template_mention_date = $date
        }
        else{
            Write-Error "String is not a valid date" -Category InvalidData -TargetObject $template_mention_date -RecommendedAction "Please provide a valid date string"
        }
    }
    rich_text_mention_template_mention_template_mention_date_structure([datetime] $template_mention_date) : base("template_mention_date")
    {
        $this.template_mention_date = $template_mention_date
    }

    static [rich_text_mention_template_mention_template_mention_date_structure] ConvertFromObject($value)
    {
        return [rich_text_mention_template_mention_template_mention_date_structure]::new($value.template_mention_date)
    }
}

class rich_text_mention_template_mention_template_mention_user_structure : rich_text_mention_template_mention_structure_base{
    [string] $template_mention_user = "me"

    rich_text_mention_template_mention_template_mention_user_structure() : base("template_mention_user")
    {
    }
    rich_text_mention_template_mention_template_mention_user_structure($template_mention_user) : base("template_mention_user")
    {
        if($template_mention_user -eq "me"){
            $this.template_mention_user = $template_mention_user
        }
        else{
            Write-Error "Only 'me' is allowed as a user in the current API Version: $global:NotionAPIVersion" -Category InvalidData -TargetObject $template_mention_user -RecommendedAction "Please provide 'me' as a user"
        }
    }

    static [rich_text_mention_template_mention_template_mention_user_structure] ConvertFromObject($value)
    {
        return [rich_text_mention_template_mention_template_mention_user_structure]::new($value.template_mention_user)
    }
}


class rich_text_mention_template_mention : rich_text_mention_base
# https://developers.notion.com/reference/rich-text#mention
{
    [rich_text_mention_template_mention_structure_base] $template_mention
    

    rich_text_mention_template_mention():base("template_mention")
    {
    }

    rich_text_mention_template_mention([rich_text_mention_template_mention_structure_base] $template_mention) :base("template_mention")
    {
        $this.template_mention = $template_mention
    }

    rich_text_mention_template_mention([string] $template_mention_unknown) :base("template_mention")
    {
        # is this a date or a user?
        [datetime]$date = Get-Date
        if ([datetime]::TryParse($template_mention_unknown, [ref]$date)) {
            $this.template_mention = [rich_text_mention_template_mention_template_mention_date_structure]::new($template_mention_unknown)
        } else {
            $this.template_mention = [rich_text_mention_template_mention_template_mention_user_structure]::new($template_mention_unknown)
        }
    }

    static [rich_text_mention_template_mention] ConvertFromObject($value)
    {
        return [rich_text_mention_template_mention]::new($value.template_mention)
    }
}
#EndRegion './Classes/Block/RichText/Type/MentionObject/05_rich_text_mention_template_mention.ps1' 87
#Region './Classes/Block/RichText/Type/MentionObject/06_rich_text_mention_user.ps1' -1

class rich_text_mention_user : rich_text_mention_base
# https://developers.notion.com/reference/rich-text#mention
{
    [notion_user] $user
    

    rich_text_mention_user():base("user")
    {
    }

    rich_text_mention_user([notion_user] $user) :base("user")
    {
        $this.user = $user
    }

    rich_text_mention_user([string] $id) :base("user")
    {
        $this.user = [notion_user]::new($id)
    }

    static [rich_text_mention_user] ConvertFromObject($value)
    {
        $rich_text_mention_user = [rich_text_mention_user]::new()
        $rich_text_mention_user.user = [notion_user]::ConvertFromObject($value)
        return $rich_text_mention_user
    }
}
#EndRegion './Classes/Block/RichText/Type/MentionObject/06_rich_text_mention_user.ps1' 28
#Region './Classes/Comment/01_comment.ps1' -1

class notion_comment
#https://developers.notion.com/reference/comment-object
{
    [string]$object = "comment"
    [string]$id
    [object]$parent
    [string]$discussion_id
    [string]$created_time
    [string]$last_edited_time
    [notion_user]$created_by
    [rich_text]$rich_text

    notion_comment()
    {
        $this.id = [guid]::NewGuid().ToString()
        $this.created_time = Get-Date -Format "yyyy-MM-ddTHH:mm:ss.fffZ" -AsUTC
    }
    
    notion_comment([string] $id)
    {
        $this.id = $id
        $this.created_time = Get-Date -Format "yyyy-MM-ddTHH:mm:ss.fffZ" -AsUTC
    }

    static [notion_comment] ConvertfromObject($Value)
    {
        $comment = [notion_comment]::new()
        $comment.id = $Value.id
        $comment.parent = $Value.parent
        $comment.discussion_id = $Value.discussion_id
        # "2022-07-15T21:46:00.000Z" -Format "yyyy-MM-ddTHH:mm:ss.fffZ"
        $comment.created_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.created_time -fieldName "created_time"
        $comment.last_edited_time = ConvertTo-NotionFormattedDateTime -InputDate $Value.last_edited_time -fieldName "last_edited_time"
        $comment.created_by = $Value.created_by
        #TODO: Convert rich_text to class [rich_text]::new()
        $comment.rich_text = $Value.rich_text.ForEach({[rich_text]::ConvertFromObject($_)})
        return $comment
    }
}
#EndRegion './Classes/Comment/01_comment.ps1' 40
#Region './Classes/Database/01_database.ps1' -1

class notion_database
# https://developers.notion.com/reference/database
{
    [string] $object = "database"
    [string] $id
    [string] $created_time
    [notion_user] $created_by
    [string] $last_edited_time
    [notion_user] $last_edited_by
    [rich_text[]] $title
    [rich_text[]] $description    
    [notion_icon] $icon
    [notion_file] $cover
    [notion_databaseproperties]$properties
    [notion_parent]$parent
    [string] $url
    [boolean] $archived
    [boolean] $in_trash
    [boolean] $is_inline
    [string] $public_url
    # Relation property (only mentioned in release notes, not in API docu)
    # [relation_type] $db_relation

    notion_database()
    {
        $this.created_time = [datetime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
    }

    notion_database([rich_text[]]$title, [notion_parent]$parent, [notion_databaseproperties]$properties)
    {
        $this.created_time = [datetime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
        $this.title = $title
        $this.parent = $parent
        $this.properties = $properties
    }

    notion_database([string]$title, [notion_parent]$parent, [notion_databaseproperties]$properties)
    {
        $this.created_time = [datetime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
        $this.title = [rich_text_text]::new($title)
        $this.parent = $parent
        $this.properties = $properties
    }

    static [notion_database] ConvertFromObject($Value)
    {
        $database_obj = [notion_database]::new()
        $database_obj.id = $Value.id
        $database_obj.created_time = $Value.created_time
        $database_obj.created_by = [notion_user]::ConvertFromObject($Value.created_by)
        $database_obj.last_edited_time = $Value.last_edited_time
        $database_obj.last_edited_by = [notion_user]::ConvertFromObject($Value.last_edited_by)
        # is an array of rich_text objects, which does not make sense
        $database_obj.title = $value.title.foreach({[rich_text]::ConvertFromObject($_)})
        $database_obj.description = $value.description.foreach({[rich_text]::ConvertFromObject($_)})
        $database_obj.icon = [notion_icon]::ConvertFromObject($Value.icon)
        $database_obj.cover = [notion_file]::ConvertFromObject($Value.cover)
        $database_obj.properties = [notion_databaseproperties]::ConvertFromObject($Value.properties)
        $database_obj.parent = [notion_parent]::ConvertFromObject($Value.parent)
        $database_obj.url = $Value.url
        $database_obj.archived = $Value.archived
        $database_obj.in_trash = $Value.in_trash
        $database_obj.is_inline = $Value.is_inline
        $database_obj.public_url = $Value.public_url
        return $database_obj
    }
}
#EndRegion './Classes/Database/01_database.ps1' 68
#Region './Classes/Database/DatabaseProperties/00_dp_base.ps1' -1

class DatabasePropertiesBase {
    #https://developers.notion.com/reference/page-property-values
    [string] $id
    [string] $name
    [notion_database_property_type] $type

    DatabasePropertiesBase() {
        $this.id = $null
        $this.name = $null
        $this.type = $null
    }

    DatabasePropertiesBase([string]$type) {
        $this.id = $null
        $this.name = $null
        $this.type = $type
    }

    DatabasePropertiesBase([string]$id, [string]$name, [notion_database_property_type]$type) {
        $this.id = $id
        $this.name = $name
        $this.type = $type
    }

    static [DatabasePropertiesBase] ConvertFromObject($Value)
    {
        $base_obj = $null
        switch ($Value.type)
        {
            "checkbox" { $base_obj = [notion_checkbox_database_property]::ConvertFromObject($Value); break }
            "created_by" { $base_obj = [notion_created_by_database_property]::ConvertFromObject($Value); break }
            "created_time" { $base_obj = [notion_created_time_database_property]::ConvertFromObject($Value); break }
            "date" { $base_obj = [notion_date_database_property]::ConvertFromObject($Value); break }
            "email" { $base_obj = [notion_email_database_property]::ConvertFromObject($Value); break }
            "files" { $base_obj = [notion_files_database_property]::ConvertFromObject($Value); break }
            "formula" { $base_obj = [notion_formula_database_property]::ConvertFromObject($Value); break }
            "last_edited_by" { $base_obj = [notion_last_edited_by_database_property]::ConvertFromObject($Value); break }
            "last_edited_time" { $base_obj = [notion_last_edited_time_database_property]::ConvertFromObject($Value); break }
            "multi_select" { $base_obj = [notion_multi_select_database_property]::ConvertFromObject($Value); break }
            "number" { $base_obj = [notion_number_database_property]::ConvertFromObject($Value); break }
            "people" { $base_obj = [notion_people_database_property]::ConvertFromObject($Value); break }
            "phone_number" { $base_obj = [notion_phone_number_database_property]::ConvertFromObject($Value); break }
            "relation" { $base_obj = [notion_relation_database_property]::ConvertFromObject($Value); break }
            "rollup" { $base_obj = [notion_rollup_database_property]::ConvertFromObject($Value); break }
            "rich_text" { $base_obj = [notion_rich_text_database_property]::ConvertFromObject($Value); break }
            "select" { $base_obj = [notion_select_database_property]::ConvertFromObject($Value); break }
            "status" { $base_obj = [notion_status_database_property]::ConvertFromObject($Value); break }
            "title" { $base_obj = [notion_title_database_property]::ConvertFromObject($Value); break }
            "url" { $base_obj = [notion_url_database_property]::ConvertFromObject($Value); break }
            "unique_id" { $base_obj = [notion_unique_id_database_property]::ConvertFromObject($Value); break }
            default {
                Write-Error "Unknown property: $($Value.type)" -Category InvalidData -RecommendedAction "Check the type of the property"
            }
        }
        try {
            $base_obj.id = $Value.id
            $base_obj.type = $Value.type
            $base_obj.name = $Value.name
        }
        catch {
            Write-Error "Error setting id and type" -Category InvalidData -RecommendedAction "Check the id and type" -TargetObject $Value
        }
        return $base_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/00_dp_base.ps1' 66
#Region './Classes/Database/DatabaseProperties/01_db.ps1' -1

class notion_databaseproperties : hashtable
# https://developers.notion.com/reference/page-property-values
{
    #[notion_page_property_type] $Type

    notion_databaseproperties()
    {
    }

    static [notion_databaseproperties] ConvertFromObject($Value)
    {
        $pageproperties = [notion_databaseproperties]::new()
        foreach ($key in $Value.PSObject.Properties.Name)
        {
            $pageproperties.Add($key, [DatabasePropertiesBase]::ConvertFromObject($Value.$key))
        }
        return $pageproperties
    }

    [void] Add([object] $Key, [object] $Value)
    {
        if (($value) -and (-not ($Value -is [DatabasePropertiesBase])))
        {
            Write-Error "Value must be of type DatabasePropertiesBase" -Category InvalidType -TargetObject $Value -RecommendedAction "Use a class that inherits from DatabasePropertiesBase"
        }
        # Call the base Add method
        ([hashtable] $this).Add($Key, $Value)
    }
}
#EndRegion './Classes/Database/DatabaseProperties/01_db.ps1' 30
#Region './Classes/Database/DatabaseProperties/02_db_checkbox.ps1' -1

class notion_checkbox_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#checkbox
{
    [hashtable] $checkbox

    notion_checkbox_database_property() : base("checkbox")
    {
        $this.checkbox = @{}
    }


    static [notion_checkbox_database_property] ConvertFromObject($Value)
    {
        return [notion_checkbox_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/02_db_checkbox.ps1' 17
#Region './Classes/Database/DatabaseProperties/03_db_created_by.ps1' -1

class notion_created_by_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#created-by
{
    [hashtable] $created_by
    
    notion_created_by_database_property() : base("created_by")
    {
        $this.created_by = @{}
    }

    static [notion_created_by_database_property] ConvertFromObject($Value)
    {
        $created_by_obj = [notion_created_by_database_property]::new()
        return $created_by_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/03_db_created_by.ps1' 17
#Region './Classes/Database/DatabaseProperties/04_db_created_time.ps1' -1

class notion_created_time_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#created-time
{
    [hashtable] $created_time

    notion_created_time_database_property() : base("created_time")
    {
        $this.created_time = @{}
    }


    static [notion_created_time_database_property] ConvertFromObject($Value)
    {
        return [notion_created_time_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/04_db_created_time.ps1' 17
#Region './Classes/Database/DatabaseProperties/05_db_date.ps1' -1


class notion_date_database_property : DatabasePropertiesBase
{
    # https://developers.notion.com/reference/property-object#date
    [hashtable] $date

    notion_date_database_property() : base("date")
    {
        $this.date = @{}
    }

    static [notion_date_database_property] ConvertFromObject($Value)
    {
        return [notion_date_database_property]::new()
    }
    
}
#EndRegion './Classes/Database/DatabaseProperties/05_db_date.ps1' 18
#Region './Classes/Database/DatabaseProperties/07_db_email.ps1' -1

class notion_email_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#email
{
    [hashtable] $email

    notion_email_database_property() : base("email")
    {
        $this.email = @{}
    }

    static [notion_email_database_property] ConvertFromObject($Value)
    {
        return [notion_email_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/07_db_email.ps1' 16
#Region './Classes/Database/DatabaseProperties/08_db_files.ps1' -1

class notion_files_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#files
{
    [hashtable] $files

    notion_files_database_property() : base("files")
    {
        $this.files = @{}
    }

    static [notion_files_database_property] ConvertFromObject($Value)
    {
        return [notion_files_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/08_db_files.ps1' 16
#Region './Classes/Database/DatabaseProperties/09_db_formula.ps1' -1

class notion_formula_database_property_structure
{
    [string] $expression

    notion_formula_database_property_structure()
    {
    }

    notion_formula_database_property_structure([string] $expression)
    {
        $this.expression = $expression
    }

    static [notion_formula_database_property_structure] ConvertFromObject($Value)
    {
        $notion_formula_database_property_structure_obj = [notion_formula_database_property_structure]::new()
        $notion_formula_database_property_structure_obj.expression = $Value.expression
        return $notion_formula_database_property_structure_obj
    }
}


class notion_formula_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/page-property-values#formula
{
    [notion_formula_database_property_structure] $formula

    notion_formula_database_property() : base("formula")
    {
        $this.formula = [notion_formula_database_property_structure]::new()
    }

    notion_formula_database_property([string]$expression) : base("formula")
    {
        $this.formula = [notion_formula_database_property_structure]::new($expression)
    }

    static [notion_formula_database_property] ConvertFromObject($Value)
    {
        $formula_obj = [notion_formula_database_property]::new()
        $formula_obj.formula = [notion_formula_database_property_structure]::ConvertFromObject($Value.formula)
        return $formula_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/09_db_formula.ps1' 45
#Region './Classes/Database/DatabaseProperties/10_db_last_edited_by.ps1' -1

class notion_last_edited_by_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#last-edited-by
{
    [hashtable] $last_edited_by

    notion_last_edited_by_database_property() : base("last_edited_by")
    {
        $this.last_edited_by = @{}
    }

    static [notion_last_edited_by_database_property] ConvertFromObject($Value)
    {
        return [notion_last_edited_by_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/10_db_last_edited_by.ps1' 16
#Region './Classes/Database/DatabaseProperties/11_db_last_edited_time.ps1' -1

class notion_last_edited_time_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#last-edited-time
{
    [hashtable] $last_edited_time

    notion_last_edited_time_database_property() : base("last_edited_time")
    {
        $this.last_edited_time = @{}
    }

    static [notion_last_edited_time_database_property] ConvertFromObject($Value)
    {
        return [notion_last_edited_time_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/11_db_last_edited_time.ps1' 16
#Region './Classes/Database/DatabaseProperties/12_db_multi_select.ps1' -1

class notion_multi_select_database_property_structure{
    [notion_multi_select_item[]] $options

    notion_multi_select_database_property_structure()
    {
        $this.options = @()
    }

    add([notion_property_color]$color, $name)
    {
        if ($this.options.Count -ge 100)
        {
            throw [System.ArgumentException]::new("The multi_select property must have 100 items or less.")
        }
        $this.options += [notion_multi_select_item]::new($color, $name)
    }

    static [notion_multi_select_database_property_structure] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_multi_select_database_property_structure]::ConvertFromObject($($Value | Convertto-json -depth 20))"
        $notion_multi_select_database_property_structure_obj = [notion_multi_select_database_property_structure]::new()
        $notion_multi_select_database_property_structure_obj.options = $Value.options.ForEach({[notion_multi_select_item]::ConvertFromObject($_)})
        return $notion_multi_select_database_property_structure_obj
    }

}


class notion_multi_select_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#multi-select
{
    [notion_multi_select_database_property_structure] $multi_select

    notion_multi_select_database_property() : base("multi_select")
    {
        $this.multi_select = [notion_multi_select_database_property_structure]::new()
    }

    notion_multi_select_database_property([notion_property_color]$color, $name) : base("multi_select")
    {
        $this.multi_select = @([notion_multi_select_database_property_structure]::new($color, $name))
    }

    add([notion_property_color]$color, $name)
    {
        $this.multi_select.add($color, $name)
    }

    static [notion_multi_select_database_property] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_multi_select_database_property]::ConvertFromObject($($Value | Convertto-json -depth 20))"
        $notion_multi_select_database_property_obj = [notion_multi_select_database_property]::new()
        $notion_multi_select_database_property_obj.multi_select = [notion_multi_select_database_property_structure]::ConvertFromObject($Value.multi_select)
        return $notion_multi_select_database_property_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/12_db_multi_select.ps1' 57
#Region './Classes/Database/DatabaseProperties/13_db_number.ps1' -1

class notion_number_database_property_structure {
    [notion_database_property_format_type] $format

    notion_number_database_property_structure() {
        $this.format = [notion_database_property_format_type]::number
    }

    notion_number_database_property_structure([notion_database_property_format_type] $format) {
        $this.format = $format
    }

    static [notion_number_database_property_structure] ConvertFromObject($Value) {
        $notion_number_database_property_structure_obj = [notion_number_database_property_structure]::new()
        $notion_number_database_property_structure_obj.format = [Enum]::Parse([notion_database_property_format_type], $Value.format)
        return $notion_number_database_property_structure_obj
    }

}


class notion_number_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#number
{
    [notion_number_database_property_structure] $number

    notion_number_database_property() : base("number")
    {
        $this.number = [notion_number_database_property_structure]::new()
    }

    notion_number_database_property($number) : base("number")
    {
        if($number -eq $null)
        {
            $this.number = [notion_number_database_property_structure]::new()
        }
        else
        {
            if($number -is [notion_number_database_property_structure])
            {
                $this.number = $number
            }
            else
            {
                $this.number = [notion_number_database_property_structure]::ConvertFromObject($number)
            }
        }
    }

    static [notion_number_database_property] ConvertFromObject($Value)
    {
        $notion_number_database_property_obj = [notion_number_database_property]::new()
        $notion_number_database_property_obj.number = [notion_number_database_property_structure]::ConvertFromObject($Value.number)
        return $notion_number_database_property_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/13_db_number.ps1' 57
#Region './Classes/Database/DatabaseProperties/14_db_people.ps1' -1

class notion_people_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#people
{
    [hashtable] $people

    notion_people_database_property() : base("people")
    {
        $this.people = @{}
        
    }

    static [notion_people_database_property] ConvertFromObject($Value)
    {
        return [notion_people_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/14_db_people.ps1' 17
#Region './Classes/Database/DatabaseProperties/15_db_phone_number.ps1' -1

class notion_phone_number_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#phone-number
{
    [hashtable] $phone_number

    notion_phone_number_database_property() : base("phone_number")
    {
        $this.phone_number = @{}
    }

    static [notion_phone_number_database_property] ConvertFromObject($Value)
    {
        return [notion_phone_number_database_property]::new()
    }   
}
#EndRegion './Classes/Database/DatabaseProperties/15_db_phone_number.ps1' 16
#Region './Classes/Database/DatabaseProperties/16_db_relation.ps1' -1

class notion_database_relation_property{
    # https://developers.notion.com/reference/property-object#relation
    [string] $database_id
    [string] $synced_property_id
    [string] $synced_property_name

    notion_database_relation_property()
    {
        $this.database_id = $null
        $this.synced_property_id = $null
        $this.synced_property_name = $null
    }

    notion_database_relation_property([string]$database_id)
    {
        $this.database_id = $database_id
    }
    
    notion_database_relation_property([string]$database_id, [string]$synced_property_id, [string]$synced_property_name)
    {
        $this.database_id = $database_id
        $this.synced_property_id = $synced_property_id
        $this.synced_property_name = $synced_property_name
    }

    static [notion_database_relation_property] ConvertFromObject($Value)
    {
        return [notion_database_relation_property]::new($Value.id, $Value.synced_property_id, $Value.synced_property_name)
    }
}

class notion_database_relation_base{
    [string] $database_id
    [notion_database_relation_type] $type

    notion_database_relation_base($type)
    {
        $this.database_id = $null
        $this.type = $type
    }

    notion_database_relation_base([string]$database_id, $type)
    {
        $this.database_id = $database_id
        $this.type = $type
    }

    static [notion_database_relation_base] ConvertFromObject($Value)
    {
        $relation_obj = $null
        switch($Value.type)
        {
            "single_property" {
                $relation_obj = [notion_database_single_relation]::ConvertFromObject($Value)
                break
            }
            "dual_property" {
                $relation_obj = [notion_database_dual_relation]::ConvertFromObject($Value)
                break
            }
            default {
                Write-Error "Invalid relation type: $Value.type" -invalidData
            }
        }
        $relation_obj.database_id = $Value.database_id
        $relation_obj.type = $Value.type
        return $relation_obj
    }

}

class notion_database_single_relation : notion_database_relation_base{
    [notion_database_relation_property] $single_property

    notion_database_single_relation() : base("single_property")
    {
        $this.single_property = [notion_database_relation_property]::new()
    }

    notion_database_single_relation([notion_database_relation_property]$single_property) : base("single_property")
    {
        $this.single_property = $single_property
    }

    notion_database_single_relation([string]$database_id, [string]$synced_property_id, [string]$synced_property_name) : base($database_id, "single_property")
    {
        $this.single_property = [notion_database_relation_property]::new($synced_property_id, $synced_property_name)
    }

    static [notion_database_single_relation] ConvertFromObject($Value)
    {
        $single_relation_obj = [notion_database_single_relation]::new()
        $single_relation_obj.single_property = [notion_database_relation_property]::ConvertFromObject($Value.single_property)
        return $single_relation_obj
    }
    
}

class notion_database_dual_relation : notion_database_relation_base{
    [notion_database_relation_property] $dual_property

    notion_database_dual_relation() : base("dual_property")
    {
        $this.dual_property = [notion_database_relation_property]::new()
    }

    notion_database_dual_relation([notion_database_relation_property]$dual_property) : base("dual_property")
    {
        $this.dual_property = $dual_property
    }

    notion_database_dual_relation([string]$database_id, [string]$synced_property_id, [string]$synced_property_name) : base($database_id, "dual_property")
    {
        $this.dual_property = [notion_database_relation_property]::new($synced_property_id, $synced_property_name)
    }

    static [notion_database_dual_relation] ConvertFromObject($Value)
    {
        $dual_relation_obj = [notion_database_dual_relation]::new()
        $dual_relation_obj.dual_property = [notion_database_relation_property]::ConvertFromObject($Value.dual_property)
        return $dual_relation_obj
    }
}


class notion_relation_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/page-property-values#relation
{
    [notion_database_relation_base] $relation

    notion_relation_database_property($relation) : base("relation")
    {
        if($relation -eq $null)
        {
            $this.relation = $null
            return
        }
        if($relation -is [notion_database_relation_base])
        {
            $this.relation = $relation
        }
        else{
            $this.relation = [notion_database_relation_base]::ConvertFromObject($relation)
        }
    }

    notion_relation_database_property() : base("relation")
    {
        $this.relation = [notion_database_relation_base]::new()
    }

    notion_relation_database_property([string]$database_id, [notion_database_relation_type] $type,[string]$synced_property_id, [string]$synced_property_name) : base("relation")
    {
        if($type -eq "single_property")
        {
            $this.relation = [notion_database_single_relation]::new($database_id, $synced_property_id, $synced_property_name)
        }
        elseif($type -eq "dual_property")
        {
            $this.relation = [notion_database_dual_relation]::new($database_id, $synced_property_id, $synced_property_name)
        }
        else{
            Write-Error "Invalid relation type: $type" -invalidData
        }
    }


    static [notion_relation_database_property] ConvertFromObject($Value)
    {
        $relation_obj = [notion_database_relation_base]::ConvertFromObject($Value.relation)
        
        return $relation_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/16_db_relation.ps1' 175
#Region './Classes/Database/DatabaseProperties/17_db_rich_text.ps1' -1

class notion_rich_text_database_property : DatabasePropertiesBase
#https://developers.notion.com/reference/property-object#rich-text
{
    # $type = "rich_text"
    [hashtable] $rich_text 
    
    notion_rich_text_database_property() : base("rich_text")
    {
        $this.rich_text = @{}
    }


    static [notion_rich_text_database_property] ConvertFromObject($Value)
    {
        return [notion_rich_text_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/17_db_rich_text.ps1' 18
#Region './Classes/Database/DatabaseProperties/18_db_rollup.ps1' -1

class notion_rollup_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#rollup
{
    [notion_rollup] $rollup

    notion_rollup_database_property() : base("rollup")
    {
        $this.rollup = [notion_rollup]::new()
    }

    notion_rollup_database_property($type_value, $function, $type) : base("rollup")
    {
        $this.rollup = [notion_rollup]::new($type_value, $function, $type)
    }

    static [notion_rollup_database_property] ConvertFromObject($Value)
    {
        $rollup_obj = [notion_rollup_database_property]::new()
        $rollup_obj.rollup = [notion_rollup]::ConvertFromObject($Value.rollup)
        return $rollup_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/18_db_rollup.ps1' 23
#Region './Classes/Database/DatabaseProperties/19_db_select.ps1' -1

class notion_select_database_property_structure{
    [notion_select[]] $options

    notion_select_database_property_structure()
    {
        $this.options = @()
    }

    add($name)
    {
        if ($this.options.Count -ge 100)
        {
            throw [System.ArgumentException]::new("The select property must have 100 items or less.")
        }
        $this.options += [notion_select]::new($name)
    }

    static [notion_select_database_property_structure] ConvertFromObject($Value)
    {
        $notion_select_database_property_structure_obj = [notion_select_database_property_structure]::new()
        $notion_select_database_property_structure_obj.options = $Value.options.ForEach({[notion_select]::ConvertFromObject($_)})
        return $notion_select_database_property_structure_obj
    }
}


class notion_select_database_property : DatabasePropertiesBase 
#https://developers.notion.com/reference/property-object#select
{
    [notion_select_database_property_structure] $select

    notion_select_database_property() : base("select")
    {
        $this.select = [notion_select_database_property_structure]::new()
    }

    notion_select_database_property($name) : base("select")
    {
        $this.select = [notion_select_database_property_structure]::new()
        $this.select.add($name)
    }


    static [notion_select_database_property] ConvertFromObject($Value)
    {
        $notion_select_database_property_obj = [notion_select_database_property]::new()
        $notion_select_database_property_obj.select =[notion_select_database_property_structure]::ConvertFromObject($value.select)
        return $notion_select_database_property_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/19_db_select.ps1' 51
#Region './Classes/Database/DatabaseProperties/20_db_status.ps1' -1

class notion_status_group
{
    [string] $id
    [string] $name
    [string] $color
    [string[]] $option_ids

    notion_status_group()
    {
    }

    static [notion_status_group] ConvertFromObject($Value)
    {
        $notion_status_group_obj = [notion_status_group]::new()
        $notion_status_group_obj.id = $Value.id
        $notion_status_group_obj.name = $Value.name
        $notion_status_group_obj.color = $Value.color
        $notion_status_group_obj.option_ids = $Value.option_ids
        return $notion_status_group_obj
    }
}

class notion_status_database_property_structure {
    [notion_status[]] $options
    [notion_status_group[]] $groups

    notion_status_database_property_structure()
    {
        $this.options = @()
        $this.groups = @()
    }

    static [notion_status_database_property_structure] ConvertFromObject($Value)
    {
        $notion_status_database_property_structure_obj = [notion_status_database_property_structure]::new()
        $notion_status_database_property_structure_obj.options = $Value.options.ForEach({[notion_status]::ConvertFromObject($_)})
        $notion_status_database_property_structure_obj.groups = $Value.groups.ForEach({[notion_status_group]::ConvertFromObject($_)})
        return $notion_status_database_property_structure_obj
    }
}


class notion_status_database_property : DatabasePropertiesBase
#https://developers.notion.com/reference/property-object#status
{
    [notion_status_database_property_structure] $status

    notion_status_database_property() : base("status")
    {
        $this.status = [notion_status_database_property_structure]::new()
    }

    static [notion_status_database_property] ConvertFromObject($Value)
    {
        $notion_status_database_property_obj = [notion_status_database_property]::new()
        $notion_status_database_property_obj.status = [notion_status_database_property_structure]::ConvertFromObject($Value.status)
        return $notion_status_database_property_obj
    }
}
#EndRegion './Classes/Database/DatabaseProperties/20_db_status.ps1' 60
#Region './Classes/Database/DatabaseProperties/21_db_title.ps1' -1

class notion_title_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#title
{
    [hashtable] $title

    notion_title_database_property() : base("title")
    {
        $this.title = @{}
    }

    #TODO Array of rich_text?
    static [notion_title_database_property] ConvertFromObject($Value)
    {
        Write-Verbose "[notion_title_database_property]::ConvertFromObject($($Value | ConvertTo-Json -Depth 10))"
        return [notion_title_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/21_db_title.ps1' 18
#Region './Classes/Database/DatabaseProperties/22_db_url.ps1' -1

class notion_url_database_property : DatabasePropertiesBase
# https://developers.notion.com/reference/property-object#url
{
    [hashtable] $url

    notion_url_database_property() : base("url")
    {
        $this.url = @{}
    }

    static [notion_url_database_property] ConvertFromObject($Value)
    {
        return [notion_url_database_property]::new()
    }
}
#EndRegion './Classes/Database/DatabaseProperties/22_db_url.ps1' 16
#Region './Classes/Database/DatabaseProperties/23_db_unique_id.ps1' -1

class notion_unique_id_database_property_structure{
    [string] $prefix

    notion_unique_id_database_property_structure()
    {
        $this.prefix = $null
    }

    notion_unique_id_database_property_structure([string] $prefix)
    {
        $this.prefix = $prefix
    }

    static [notion_unique_id_database_property_structure] ConvertFromObject($Value)
    {
        $notion_unique_id_database_property_structure_obj = [notion_unique_id_database_property_structure]::new()
        $notion_unique_id_database_property_structure_obj.prefix = $Value.prefix
        return $notion_unique_id_database_property_structure_obj
    }
}



class notion_unique_id_database_property : DatabasePropertiesBase
{
    [notion_unique_id_database_property_structure] $unique_id
    
    notion_unique_id_database_property() : base("unique_id")
    {
        $this.unique_id = [notion_unique_id_database_property_structure]::new()
    }
    
    notion_unique_id_database_property([string]$prefix) : base("unique_id")
    {
        $this.unique_id = [notion_unique_id_database_property_structure]::new($prefix)
    }

    static [notion_unique_id_database_property] ConvertFromObject($Value)
    {
        $unique_id_obj = [notion_unique_id_database_property]::new()
        $unique_id_obj.unique_id = [notion_unique_id_database_property_structure]::ConvertFromObject($Value.unique_id)
        return $unique_id_obj
    }
}   
#EndRegion './Classes/Database/DatabaseProperties/23_db_unique_id.ps1' 45
#Region './Classes/Emoji/01_emoji.ps1' -1

class notion_emoji : notion_icon
# https://developers.notion.com/reference/notion_emoji-object
{
    [icontype]$type = "emoji"
    [string]$emoji

    notion_emoji()
    {
        $this.emoji = $null
    }

    notion_emoji($emoji)
    {
        $this.emoji = $emoji
    }

    static [notion_emoji] ConvertFromObject($Value)
    {
        return [notion_emoji]::new($Value.emoji)
    }
}
#EndRegion './Classes/Emoji/01_emoji.ps1' 22
#Region './Classes/Emoji/02_Custom_Emoji.ps1' -1

class custom_emoji_structure
{
    [string]$id
    [string]$name
    [string]$url

    custom_emoji_structure()
    {
        $this.id = $null
        $this.name = $null
        $this.url = $null
    }

    custom_emoji_structure($id, $name, $url)
    {
        $this.id = $id
        $this.name = $name
        $this.url = $url
    }

    static [custom_emoji_structure] ConvertFromObject($Value)
    {
        return [custom_emoji_structure]::new($Value.id, $Value.name, $Value.url)
    }

}   
class notion_custom_emoji
# https://developers.notion.com/reference/emoji-object#custom-emoji
{
    [icontype]$type = "custom_emoji"
    [string]$custom_emoji

    notion_custom_emoji()
    {
        $this.custom_emoji = $null
    }

    notion_custom_emoji([notion_custom_emoji]$custom_emoji)
    {
        $this.custom_emoji = $custom_emoji
    }

    static [notion_custom_emoji] ConvertFromObject($Value)
    {
        $custom_emojiObj = [notion_custom_emoji]::new()
        $custom_emojiObj.custom_emoji = [custom_emoji_structure]::ConvertFromObject($Value.custom_emoji)
        return $custom_emojiObj
    }
}
#EndRegion './Classes/Emoji/02_Custom_Emoji.ps1' 50
#Region './Classes/Parent/00_parent.ps1' -1

class notion_parent
{
    #https://developers.notion.com/reference/parent-object
    [notion_parent_type]$type

    notion_parent()
    {
    }

    notion_parent([notion_parent_type]$type)
    {
        $this.type = $type
    }

    notion_parent([notion_parent_type]$type, [string]$id)
    {
        $this = $this::ConvertFromObject(@{type=$type; id=$id})
    }

    static [notion_parent] ConvertFromObject($Value)
    {
        $parent_obj = $null
        switch ($Value.type) {
            "database_id" {
                $parent_obj = [notion_database_parent]::ConvertFromObject($Value)
            }
            "page_id" {
                $parent_obj = [notion_page_parent]::ConvertFromObject($Value)
            }
            "workspace" {
                $parent_obj = [notion_workspace_parent]::ConvertFromObject($Value)
            }
            "block_id" {
                $parent_obj = [notion_block_parent]::ConvertFromObject($Value)
            }
            default {
                Write-Error "Unknown parent type: $($Value.type)" -Category InvalidData -RecommendedAction "Check the parent type and try again. Supported types are: database, page, workspace, block"
            }
        }
        return $parent_obj
    }
}
#EndRegion './Classes/Parent/00_parent.ps1' 43
#Region './Classes/Parent/01_database_parent.ps1' -1

class notion_database_parent : notion_parent{
    [string] $database_id

    notion_database_parent() : base("database_id")
    {
    }

    notion_database_parent([string]$database_id) : base("database_id")
    {
        $this.database_id = $database_id
    }

    static [notion_database_parent] ConvertFromObject($Value)
    {
        return [notion_database_parent]::new($Value.database_id)
    }
}
#EndRegion './Classes/Parent/01_database_parent.ps1' 18
#Region './Classes/Parent/02_page_parent.ps1' -1

class notion_page_parent : notion_parent{
    [string] $page_id

    notion_page_parent() : base("page_id")
    {
    }

    notion_page_parent([string]$page_id) : base("page_id")
    {
        $this.page_id = $page_id
    }

    static [notion_page_parent] ConvertFromObject($Value)
    {
        return [notion_page_parent]::new($Value.page_id)
    }
}
#EndRegion './Classes/Parent/02_page_parent.ps1' 18
#Region './Classes/Parent/03_workspace_parent.ps1' -1

class notion_workspace_parent : notion_parent{
    [bool] $workspace = $true

    notion_workspace_parent() : base("workspace")
    {
    }

    static [notion_workspace_parent] ConvertFromObject($Value)
    {
        return [notion_workspace_parent]::new()
    }

}
#EndRegion './Classes/Parent/03_workspace_parent.ps1' 14
#Region './Classes/Parent/04_block_parent.ps1' -1

class notion_block_parent : notion_parent{
    [string] $block_id

    notion_block_parent() : base("block_id")
    {
    }

    notion_block_parent([string]$block_id) : base("block_id")
    {
        $this.block_id = $block_id
    }

    static [notion_block_parent] ConvertFromObject($Value)
    {
        return [notion_block_parent]::new($Value.block_id)
    }
}
#EndRegion './Classes/Parent/04_block_parent.ps1' 18
#Region './Classes/Unfurl attribute/01_unfurl_attribute.ps1' -1

class notion_unfurl_attribute
# https://developers.notion.com/reference/unfurl-attribute-object
{
    [string]$id
    [string]$name
    [string]$type

    #TODO: Implement constructor
}
#EndRegion './Classes/Unfurl attribute/01_unfurl_attribute.ps1' 10
#Region './Classes/Unfurl attribute/02_sub_type.ps1' -1

class notion_sub_type_unfurl_attribute
# https://developers.notion.com/reference/unfurl-attribute-object#inline-sub_type-objects
{
    $color
    $date
    $datetime
    $enum
    $plain_text
    $title

    sub_type($color, $date, $datetime, $enum, $plain_text, $title)
    {
        $this.color = $color
        $this.date = $date
        $this.datetime = $datetime
        $this.enum = $enum
        $this.plain_text = $plain_text
        $this.title = $title
    }
}
#EndRegion './Classes/Unfurl attribute/02_sub_type.ps1' 21
#Region './Classes/Unfurl attribute/03_sub-type-child.ps1' -1

class notion_sub_type_child_unfurl_attribute
{
    # https://developers.notion.com/reference/unfurl-attribute-object#embed-sub_type_child-objects
    $audio
    $html
    $image
    $video

    #TODO: Implement constructor
}
#EndRegion './Classes/Unfurl attribute/03_sub-type-child.ps1' 11
#Region './Classes/Unfurl attribute/04_section.ps1' -1

class notion_section_unfurl_attribute
# https://developers.notion.com/reference/unfurl-attribute-object#the-section-value
{
    #TODO: all properties or derived classes
}
#EndRegion './Classes/Unfurl attribute/04_section.ps1' 6
#Region './Private/Add-NotionLogToFile.ps1' -1

function Add-NotionLogToFile
{
    <#
    .SYNOPSIS
    Add-NotionLogToFile -filename <filename> -level <DEBUG | INFO | WARNING |ERROR> -message <string|array|object>

    .DESCRIPTION
    Long description

    .PARAMETER filename
    Name of file the log file to be written

    .PARAMETER level
    Type of loglevel: DEBUG | INFO | WARNING |ERROR

    .PARAMETER message
    text, array or object to be displayed/written to logfile/written to JSON file

    .PARAMETER DN
    Active Directory: Distinguished Name

    .PARAMETER Typeofaction
    Type of AD mofification: creation | modify | delete | member-added | member-removed

    .PARAMETER Objectclass
    Type of affected AD object: user | group

    .PARAMETER ADchange
    Boolean Param if a change has been done on AD

    .PARAMETER requestID
    If launched from a request: ID of the Request

    .PARAMETER Service
    Service that is launching the command

    .PARAMETER expandObject
    If the message is an object, it will be expanded to all properties

    .EXAMPLE
    Add-NotionLogToFile -filename $log -level INFO -message "someting was successful"

    .EXAMPLE
    Add-NotionLogToFile -filename $log -level DEBUG -message "try to ADD Member: $($MEMBER)..."

    .EXAMPLE
    $Error | Add-NotionLogToFile -filename $log -level ERROR

    .EXAMPLE
    "Some text", $object | Add-NotionLogToFile -filename $log -level ERROR

    #>
    [CmdletBinding()]
    param
    (
        [Parameter(Mandatory = $false)]
        [string]$filename,
        [ValidateSet('DEBUG', 'INFO', 'WARN', 'ERROR', 'VERBOSE')]
        [Parameter(Mandatory = $true)]
        [string]$level,
        [Parameter(ValueFromPipeline = $true, Mandatory = $true)]
        [object]$message,
        [string]$DN,
        [ValidateSet('creation', 'modify', 'delete', 'member-added', 'member-removed')]
        [Parameter(Mandatory = $false)]
        [string]$Typeofaction,
        [ValidateSet('user', 'group')]
        [Parameter(Mandatory = $false)]
        [string]$Objectclass,
        [ValidateSet('true', 'false')]
        [Parameter(Mandatory = $false)]
        [switch]$ADchange,
        [Parameter(Mandatory = $false)]
        [string]$requestID = $json.requestID,
        [Parameter(Mandatory = $false)]
        # https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_operators?view=powershell-7.2#null-coalescing-operator-
        # Selects the second value if first one is empty
        [string]$Service = $json.requestType,
        [switch]$expandObject
    )
    process
    {
        #BUG: ParameterSet for Azure Changes
        if ($global:logOFF)
        {
            return
        }
        switch ($level)
        {
            "VERBOSE"
            {
                if ($env:LEVEL -ne "VERBOSE")
                {
                    return
                }
                $color = "Cyan"
                break
            }
            "DEBUG"
            {
                if ($env:LEVEL -ne "DEBUG" -and $env:LEVEL -ne "VERBOSE")
                {
                    return
                }
                $color = "DarkMagenta"
                break
            }
            "WARN"
            {
                $color = "Yellow"
                break
            }
            "ERROR"
            {
                $color = "Red"
                break
            }
            default
            {
                $color = "white"
            }
        }
        if ($message.GetType().Name -notlike "*string*")
        {
            if ($expandObject -eq $true)
            {
                $message = "`n$($message | Select-Object * | Out-String)"
            }
            else
            {
                $message = "`n$($message | Out-String)"
            }
        }
        if (-not [string]::IsNullOrEmpty($filename))
        {
            $mutex = New-Object System.Threading.Mutex($false, "Global\Add-NotionLogToFile")
            $mutex.WaitOne() | Out-Null
                (Get-Date).ToString() + " - " + $level + " - " + $message >> $filename
            #json log
            if ($ADchange -eq $true)
            {
                if (!(Test-Path -Path $jsonlogPath))
                {
                    try
                    {
                        $null = New-Item -Path $jsonlogPath -ItemType Directory
                        Write-Host ("Path: ""{0}"" was created." -f $jsonlogPath)
                    }
                    catch
                    {
                        Write-Host ("Path: ""{0}"" couldn't be created." -f $jsonlogPath)
                    }
                }
                else
                {
                    Write-Verbose ("Path: ""{0}"" already exists." -f $jsonlogPath)
                }
                $time = $(Get-Date -Format dd.MM.yyyy-HH:mm:ss)
                [string]$logFilejson = '{0}\{1}_{2}.json' -f $jsonlogPath, $(Get-Date -Format 'yyyyMMdd'), ($env:taskID ?? $Service)
                [array]$output = @(New-Object psobject -Property @{Name = "$Service"; Type = "$level"; RequestID = "$requestID"; Text = "$message"; Time = "$time"; <#InitiatedBy = "$InitiatedBy"; Targetuser = "$TargetUserId"; #>DN = "$DN"; Typeofaction = "$Typeofaction"; Objectclass = "$Objectclass"; ADchange = "$ADchange" })
                if ((Test-Path -Path $logFilejson -PathType leaf))
                {
                    Add-Content -Path $logFilejson -Value ", "
                }
                Add-Content -Path $logFilejson -Value $($output | ConvertTo-Json)
            }
            $mutex.ReleaseMutex() | Out-Null
        }
        Write-Host "$($level) - $($message)" -ForegroundColor $color
    }
}
#EndRegion './Private/Add-NotionLogToFile.ps1' 172
#Region './Private/ConvertTo-NotionFormattedDateTime.ps1' -1

function ConvertTo-NotionFormattedDateTime {
    <#
    .SYNOPSIS
        Converts an input date to a specified Notion formatted date-time string.
    
    .DESCRIPTION
        The ConvertTo-NotionFormattedDateTime function takes an input date and converts it to a Notion formatted date-time string.
        The input date can be a string or a datetime object. If the input is a string, the function attempts to parse it into a datetime object.
        If the parsing fails, an error is logged.
    
    .PARAMETER InputDate
        The date to be converted. This parameter is mandatory.
    
    .PARAMETER fieldName
        The name of the field for logging purposes. This parameter is optional and defaults to "not_provided". This parameter is used for logging purposes.
    
    .EXAMPLE
        ConvertTo-NotionFormattedDateTime -InputDate "2023-10-01T12:34:56Z"
        Converts the input string date to the default Notion formatted date-time string.
    
    .NOTES
        If the input date is already a datetime object, it is directly converted to the specified format.
        If the input date is a string, the function attempts to parse it. If parsing fails, an error is logged.
        If the input type is neither string nor datetime, an error is logged and $null is returned.
    
    .OUTPUTS
        Returns a formatted date-time string if the conversion is successful.
        Returns $null if the conversion fails.
    
    .LINK
        https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/get-date
        https://docs.microsoft.com/en-us/dotnet/api/system.datetime.tostring
    #>
    [cmdletbinding()]
    [OutputType([String])]
    param (
        [Parameter(Mandatory = $true)]
        $InputDate,
        [Parameter(Mandatory = $false)]
        $fieldName = "not_provided"
        )
    $Format = "yyyy-MM-ddTHH:mm:ss.fffZ"

    # Check if the input is already a datetime object
    if ($InputDate -is [datetime]) {
        return $InputDate.ToUniversalTime().ToString($Format)
    }
    # Check if the input is a string and attempt to parse it
    elseif ($InputDate -is [string]) {
        $dateObj = [datetime]::UtcNow
        if ([datetime]::TryParse($InputDate, [ref]$dateObj)) {
            return $dateObj.ToUniversalTime().toString($Format)
        }
        else {
            # Log an error for invalid format
            Write-Error "Invalid date time format in field $fieldName" -Category InvalidData -TargetObject $value -RecommendedAction "Please provide a valid datetime format"
            return $null
        }
    }
    else {
        # Handle cases where the type is neither string nor datetime
        Write-Error "Invalid input type for field $fieldName" -Category InvalidData -TargetObject $value -RecommendedAction "Please provide a valid datetime format"
        return $null
    }
}
#EndRegion './Private/ConvertTo-NotionFormattedDateTime.ps1' 66
#Region './Private/Copy-NotionVariable.ps1' -1

function Copy-NotionVariable
{
    <#
    .SYNOPSIS
    Copy the content of a variable to a new variable

    .DESCRIPTION
    Copy the content of a variable to a new variable, this is useful when you want to create a new variable with the same content as the source variable, without having a reference to the source variable.

    .PARAMETER Variable
    The Source variable

    .PARAMETER asHashtable
    If set, the variable will be converted to a hashtable

    .EXAMPLE
    Copy-NotionVariable -Variable $Variable
    #>
    param (
        [Parameter(Mandatory = $true)]
        [Alias("Object")]
        $Variable,
        [switch]$asHashtable
    )
    return (ConvertTo-Json -InputObject $Variable | ConvertFrom-Json -AsHashtable:$asHashtable)
}
#EndRegion './Private/Copy-NotionVariable.ps1' 27
#Region './Private/Remove-NullValuesFromObject.ps1' -1


function Remove-NullValuesFromObject
{
    [CmdletBinding()]
    [OutputType([PSCustomObject])]
    param (
        [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
        [object]$InputObject
    )

    process
    {
        # Ensure enums are serialized as strings
        $InputObject = $InputObject | ConvertTo-Json -Depth 20 -EnumsAsStrings | ConvertFrom-Json
        $outputObject = [PSCustomObject]@{}
        # Remove null properties from the input object
        :loop foreach ($property in $InputObject.PSObject.Properties)
        {
            if (-not ($property.IsSettable))
            {
                continue :loop
            }
            if ($null -ne $property.Value)
            {
                Write-Debug "Processing property: $($property.Name): $($property.Value) `<$($property.value.GetType().Name)]"
                if (($property.value -is [int]) -or ($property.value -is [int64]) -or ($property.value -is [double]) -or ($property.value -is [float]) -or ($property.value -is [string]) -or ($property.value -is [bool]))
                {
                    $outputObject | Add-Member -MemberType NoteProperty -Name $property.Name -Value $property.Value
                }
                elseif ($property.Value -is [array])
                {
                    $cleanedArray = @()
                    foreach ($item in $property.Value)
                    {
                        if ($item -is [Object])
                        {
                            $cleanedArray += Remove-NullValuesFromObject -InputObject $item
                        }
                        else
                        {
                            $cleanedArray += $item
                        }
                    }
                    $outputObject | Add-Member -MemberType NoteProperty -Name $property.Name -Value $cleanedArray
                }
                elseif ($property.Value -is [Object] ) 
                {
                    try
                    {
                        $nestedObject = Remove-NullValuesFromObject -InputObject $property.Value                        
                    }
                    catch
                    {
                        Write-Host "Error in property: $($property.Name)" -ForegroundColor Red
                        Write-Host $_.Exception.Message -ForegroundColor Red                        
                    }
                    $outputObject | Add-Member -MemberType NoteProperty -Name $property.Name -Value $nestedObject
                }
                else
                {
                    $outputObject | Add-Member -MemberType NoteProperty -Name $property.Name -Value $property.Value
                }
            }
        }

        # Return cleaned object
        return $outputObject
    }
}
#EndRegion './Private/Remove-NullValuesFromObject.ps1' 70
#Region './Public/Add-NotionHeaderToBlock.ps1' -1

function Add-NotionHeaderToBlock
{
    <#
    .SYNOPSIS
    Adds a Notion header block to a specified parent block.
    
    .DESCRIPTION
    The Add-NotionHeaderToBlock function creates a header block in Notion with specified properties such as text, color, level, and toggleability, and adds it to a given parent block. It can also accept an existing header object.
    
    .PARAMETER Text
    The text content of the header.
    
    .PARAMETER Color
    The color of the header.
    
    .PARAMETER Level
    The level of the header (1-3).
    
    .PARAMETER is_toggleable
    Indicates if the header is toggleable.
    
    .PARAMETER Parent
    The parent block to which the header will be added.
    
    .PARAMETER InputObject
    An existing header object to be added to the parent block.
    
    .EXAMPLE
    Add-NotionHeaderToBlock -Text "My Header" -Color "blue" -Level 1 -is_toggleable $true -Parent $parentBlock
    
    This example creates a new header with the text "My Header", color "blue", level 1, and toggleable, and adds it to the specified parent block.
    
    .EXAMPLE
    $header = New-NotionHeader -Text "My Header" -Color "blue" -Level 1 -is_toggleable $true
    Add-NotionHeaderToBlock -InputObject $header -Parent $parentBlock
    
    This example creates a new header object and then adds it to the specified parent block using the InputObject parameter.
    #>
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, ParameterSetName = "Params", HelpMessage = "Text of the Header")]
        [string] $Text,
        [Parameter(Mandatory = $true, ParameterSetName = "Params", HelpMessage = "Color of the Header")]
        [notion_color] $Color,
        [Parameter(Mandatory = $true, ParameterSetName = "Params", HelpMessage = "Level of the Header (1-3)")]
        [int] $Level,
        [Parameter(Mandatory = $true, ParameterSetName = "Params", HelpMessage = "Is the Header toggleable")]
        [boolean]  $is_toggleable,
        [Parameter(Mandatory = $true, HelpMessage = "The parent block to add the header to")]
        [notion_block] $Parent,
        [Parameter(Mandatory = $true, ParameterSetName = "Object")]
        [Alias("Object")]
        [Heading] $InputObject
    )
    
    process
    {
        
        if ($PSCmdlet.ParameterSetName -eq "Object")
        {
            $heading = $InputObject
        }
        else
        {
            $PSBoundParameters.Remove("Parent") | Out-Null
            $heading = New-NotionHeader @PSBoundParameters
        }
        $Parent.addChild($heading)
        #also accepts a page ID
        return Invoke-NotionApiCall -Uri "/blocks/$($Parent.id)/children" -Method PATCH -body $Parent
    }
}
#EndRegion './Public/Add-NotionHeaderToBlock.ps1' 73
#Region './Public/Block/Add-NotionBlockToPage.ps1' -1

function Add-NotionBlockToPage
{
    <#
    .SYNOPSIS
    Adds one or more Notion blocks to a specified Notion page.

    .DESCRIPTION
    The Add-NotionBlockToPage function allows adding Notion blocks to an existing Notion page.
    The function takes a notion_page object representing the parent page and one or more
    notion_block objects representing the content to be added. It then makes an API request
    to update the page with the new blocks.

    .PARAMETER Page
    Specifies the parent Notion page to which the block(s) will be added.
    Type: notion_page
    Required: Yes
    Position: Named
    Accept pipeline input: No
    ParameterSetName: Page
    Help Message: The parent page to add the block to.

    .PARAMETER PageID
    Specifies the page id of the parent page.
    Type: string
    Required: Yes
    Position: Named
    Accept pipeline input: No
    ParameterSetName: PageID
    Help Message: The page id of the parent page.

    .PARAMETER Block
    Specifies the Notion block(s) to be added to the page.
    Type: notion_block[]
    Required: Yes
    Position: Named
    Accept pipeline input: No
    Help Message: The block to add to the page.

    .EXAMPLE
    
    $Page = Get-NotionPage -Id "12345678-90ab-cdef-1234-567890abcdef"
    $Block = New-NotionBlock -Type "paragraph" -Text "Hello, Notion!"
    Add-NotionBlockToPage -Page $Page -Block $Block

    Description: This example retrieves a Notion page by ID and creates a new paragraph
    block, then adds it to the page.

    .EXAMPLE
    
    $Page = Get-NotionPage -Id "12345678-90ab-cdef-1234-567890abcdef"
    $Block1 = New-NotionBlock -Type "heading_1" -Text "Main Heading"
    $Block2 = New-NotionBlock -Type "paragraph" -Text "This is a paragraph under the heading."
    Add-NotionBlockToPage -Page $Page -Block @($Block1, $Block2)

    Description: This example retrieves a Notion page and adds a heading block followed
    by a paragraph block to it.

    .OUTPUTS
    The function returns the response from the Notion API after attempting to add
    the blocks to the specified page.

    .NOTES
    - This function currently requires a notion_page object as input. Future updates
    may add support for specifying a Page ID directly.
    - The function converts the blocks into JSON before making an API request.

    .LINK
    https://developers.notion.com/reference/patch-block-children
    #>
    [OutputType([notion_block[]])]
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, HelpMessage = "The parent page to add the block to", ParameterSetName = "Page")]
        [notion_page] $Page,
        [Parameter(Mandatory = $true, HelpMessage = "The page id of the parent page", ParameterSetName= "PageID")]
        $pageID,
        [Parameter(Mandatory = $true, HelpMessage = "The block to add to the page")]
        [notion_block[]] $Block
    )
    
    process
    {
        Write-Debug "Adding block(s) to page $($Page.id)"
        $pageID ??= $Page.id
        $blocks = $block | ConvertTo-Json -Depth 10 -EnumsAsStrings
        $response =  Invoke-NotionApiCall -Uri "/blocks/$($Page.id)/children" -Method PATCH -body $blocks
        return [notion_block[]]@($response.foreach({ [notion_block]::ConvertFromObject($_) }))
    }
}
#EndRegion './Public/Block/Add-NotionBlockToPage.ps1' 90
#Region './Public/Block/Get-NotionBlock.ps1' -1

function Get-NotionBlock() 
{
    <#
    .SYNOPSIS
        Retrieves a Notion block and its children up to a specified depth.

    .DESCRIPTION
        The Get-NotionBlock function retrieves a Notion block and its children up to a specified depth.
        It can accept either a block object or a block ID as input.

    .PARAMETER Block
        The block to get the children from. This parameter is mandatory if using the "Object" parameter set.

    .PARAMETER BlockId
        The block ID to get the children from. This parameter is mandatory if using the "ID" parameter set.

    .PARAMETER maxDepth
        The maximum depth of children to retrieve. The default value is 5.

    .EXAMPLE
        
        $block = Get-NotionBlock -BlockId "some-block-id" -maxDepth 3
        

    .EXAMPLE
    
        $block = Get-NotionBlock -Block $someBlockObject -maxDepth 2
    .OUTPUTS
        [notion_block]
        Returns a notion_block object representing the specified block and its children.

    .NOTES
        This function requires the Invoke-NotionApiCall and Get-NotionBlockChildren functions to be defined.
    .LINK
        https://developers.notion.com/reference/get-block-children
    #>
    [OutputType([notion_block])]
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, HelpMessage = "The block to get the children from", ParameterSetName = "Object")]
        [notion_block] $Block,
        [Parameter(Mandatory = $true, HelpMessage = "The block Id to get the children from", ParameterSetName = "ID")]
        [string] $BlockId,
        $maxDepth = 5
    )

    process {
        if ($PSCmdlet.ParameterSetName -eq "Object") 
        {
            $BlockId = $Block.id
        }
        $block = Invoke-NotionApiCall -Uri "/blocks/$BlockId" -Method GET
        $block = [notion_block]::ConvertFromObject($block)
        if ($block.has_children -and $maxDepth -gt 0)
        {
            $objects = Get-NotionBlockChildren -Block $block
            $children = $objects | Get-NotionBlock -maxDepth ($maxDepth - 1)
            $block.addChildren($children)
        }
        return $block
    }
}
#EndRegion './Public/Block/Get-NotionBlock.ps1' 63
#Region './Public/Block/Get-NotionBlockChildren.ps1' -1

function Get-NotionBlockChildren 
{
    <#
    .SYNOPSIS
    Retrieves the children blocks of a specified Notion block.

    .DESCRIPTION
    The `Get-NotionBlockChildren` function retrieves all child blocks of a given Notion block by its ID or object representation. It uses the Notion API to fetch the child blocks and converts the response into an array of `notion_block` objects.

    .PARAMETER Block
    Specifies the Notion block object whose children should be retrieved. This parameter is part of the "Block" parameter set and is mandatory when used.

    .PARAMETER BlockId
    Specifies the unique identifier of the Notion block whose children should be retrieved. This parameter is part of the "Id" parameter set and is mandatory when used.

    .PARAMETERSETNAME Block
    The "Block" parameter set allows specifying a Notion block object to derive the `BlockId` for the API call.

    .PARAMETERSETNAME Id
    The "Id" parameter set allows specifying the `BlockId` directly to retrieve the children.

    .OUTPUTS
    [notion_block[]]
    Returns an array of `notion_block` objects representing the child blocks of the specified Notion block.

    .NOTES
    - The function supports two parameter sets for flexibility: specifying a block object or its ID directly.
    - Ensure that the Notion API is properly configured and authorized for use.

    .EXAMPLE
    Get-NotionBlockChildren -BlockId "12345abcde"

    Retrieves the child blocks of the Notion block with the ID `12345abcde`.

    .EXAMPLE
    $block = Get-NotionBlock -Id "67890fghij"
    Get-NotionBlockChildren -Block $block

    Retrieves the child blocks of the specified Notion block object.

    .EXAMPLE
    "12345abcde", "67890fghij" | ForEach-Object { Get-NotionBlockChildren -BlockId $_ }

    Retrieves the child blocks for multiple Notion blocks by their IDs using pipeline input.

    .LINK
    https://developers.notion.com/reference/get-block-children
    
    #>

    [OutputType([notion_block[]])]
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, ParameterSetName = "Block" , HelpMessage = "The block to get the children from")]
        [notion_block] $Block,
        [Parameter(Mandatory = $true, ParameterSetName = "Id" , HelpMessage = "The block Id to get the children from")]
        [alias("Id")]
        [string] $BlockId
    )

    process {
        if ($PSCmdlet.ParameterSetName -eq "Block") {
            $BlockId = $Block.id
        }

        $uri = "/blocks/$BlockId/children"
        $response = Invoke-NotionApiCall -uri $uri -method "GET"
        return [notion_block[]]@($response.foreach({[notion_block]::ConvertFromObject($_)}))
    }
}
#EndRegion './Public/Block/Get-NotionBlockChildren.ps1' 71
#Region './Public/Connect-Notion.ps1' -1

function Connect-Notion
{
    <#
    .SYNOPSIS
    Connects to the Notion API using the provided Bearer token and URL.
    
    .DESCRIPTION
    The Connect-Notion function is used to establish a connection to the Notion API. It requires a Bearer token and the URL to the Notion API. Optionally, you can specify the API version.

    How to obtain an Bearer Token / Notion API Key / Integration Key?
    1. Register a new account at [https://notion.com](https://notion.com)
    2. [https://developers.notion.com](https://developers.notion.com) -> Click "View my integrations"
    3. At "My integrations" click Add (**+**)
    4. Select the name, workspace, type and logo - Click "Save"
    5. Click on "Configure"
    6. Secret -> Click on "Show"
    7. Click on "Copy"
    8. That's your Bearer Token / API Key / Integration Token
    
    .PARAMETER BearerToken
    The Bearer token (aka APIKey) used for authentication. This parameter is mandatory.
    
    .PARAMETER notionURL
    The URL to the Notion API. This parameter is optional and defaults to 'https://api.notion.com/v1'
    
    .PARAMETER APIVersion
    The version of the Notion API to use. Valid values are '2022-02-22' and '2022-06-28'. This parameter is optional and defaults to '2022-06-28'.
    
    .EXAMPLE
    Connect-Notion -BearerToken $secureToken -notionURL "https://api.notion.com/v1" -APIVersion '2022-06-28'
    
    Connects to the Notion API using the specified Bearer token, URL, and API version.
    .EXAMPLE
    $BearerToken = Read-Host -Prompt "Enter your Bearer token" | ConvertTo-Securestring -AsPlainText
    Connect-Notion -BearerToken $BearerToken

    Asks for the API token and connects to the Notion API.
    
    .OUTPUTS
    System.Collections.Hashtable
    Returns a hashtable containing the URL and API version used for the connection.
    
    #>
    param (
        [Parameter(Mandatory = $true, HelpMessage = "The Bearer token used for authentication as secure string")]
        [Alias("bearer")]
        [securestring]$BearerToken,
        [Parameter(Mandatory = $false, HelpMessage = "The URL to Notion e.g. https://api.notion.com/v1")]
        [string]$notionURL = "https://api.notion.com/v1",
        [ValidateSet('2022-02-22', '2022-06-28')]
        [Parameter(Mandatory = $false, HelpMessage = "The API version '2022-02-22' or '2022-06-28'")]
        [string]$APIVersion = '2022-06-28'
    )
    
    # Test connection
    $result = Invoke-NotionApiCall "$notionURL/search" -APIKey $BearerToken -APIVersion $APIVersion -first 1 -method POST -body @{
        "query" = ""
        filter  = @{
            "property" = "object"
            "value"    = "page"
        }
        sort    = @{
            "direction" = "ascending"
            "timestamp" = "last_edited_time"
        }
    }
    if ($result -eq $null)
    {
        Write-Error "Failed to connect to Notion API." -RecommendedAction "Please check your Bearer token and URL." -Category ConnectionError
        return
    }
    $global:NotionAPIKey = $BearerToken
    $global:NotionApiUri = $notionURL
    $global:NotionAPIVersion = $APIVersion
    Write-Host "Successfully connected to Notion API." -ForegroundColor Green

    return @{
        url     = $global:NotionApiUri
        version = $global:NotionAPIVersion
    }
}
#EndRegion './Public/Connect-Notion.ps1' 82
#Region './Public/ConvertTo-NotionObject.ps1' -1

function ConvertTo-NotionObject
{
    <#
    .SYNOPSIS
    Converts an object to a TypeScript Notion object.
    
    .DESCRIPTION
    This function takes an object and converts it to a TypeScript Notion object.
    
    .PARAMETER InputObject
    The object to be converted.

    .PARAMETER Object
    The object to be converted. (Alias for InputObject)
    
    .OUTPUTS
    The converted Notion object.
    
    .EXAMPLE
    $object = @{ object = "block"; type = "code" }
    $convertedObject = ConvertTo-NotionObject -Object $object

    Returns an block object of type "code".

    .EXAMPLE
    $object = @{ object = "list"; results = @(@{ object = "block"; type = "paragraph" }, @{ object = "block"; type = "heading_1" }) }
    $object | ConvertTo-NotionObject

    Returns a list object with two block objects of type "paragraph" and "heading_1".

    .EXAMPLE
    $object = @{ object = "block"; type = "bookmark" }
    ConvertTo-NotionObject -InputObject $object

    Returns a block object of type "bookmark".
    #>
    [CmdletBinding()]
    param (
        [Parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true, HelpMessage = "The input object to convert to a Notion object based on classes")]
        [Alias("Object")]
        $InputObject
    )
    

    begin
    {
        # if ($_) { $InputObject = $_ }
        # $InputObject.GetType().BaseType
        # if (!(($InputObject -is [System.Object]) -or ($InputObject -is [System.Array])))
        # {
        # $Type = $InputObject.GetType().BaseType
        # "Input is not an array or object (is $Type)" | Add-NotionLogToFile -Level ERROR
        # Break
        # }
        $output = @()
    }
    process
    {
        foreach ($item in $InputObject)
        {
            if ($item.template)
            {
                "Template - not implemented yet" | Add-NotionLogToFile -Level WARN
                return
            }

        
        ("Object: {0} Type: {1}" -f $item.object, $item.Type) | Add-NotionLogToFile -Level DEBUG
            "Object", $item | Add-NotionLogToFile -Level DEBUG
            #TODO: Constructor für jede Klasse erstellen .ConvertfromObject() -> $Object = [NotionObject]::new().ConvertfromObject($item)
            switch ($item.object)
            {
                "list"
                {  
                    "List" | Add-NotionLogToFile -Level DEBUG
                    #TODO: Gibt's einen Object Type List?
                    if ($item.results -is [array])
                    {
                        foreach ($result in $item.results)
                        {
                            $result | ConvertTo-NotionObject
                        }
                    }
                    #TODO: $out = [notion_block]::new()
                    # Block vom Typ List erstellen
                    # Children aus den Einzelobjekten hinzufügen
                }

                "block"
                {
                    # https://developers.notion.com/reference/block
                    "Block" | Add-NotionLogToFile -Level DEBUG
                    $output += [notion_block]::ConvertFromObject($item)
                }
        
                "comment"
                {  
                    "Comment" | Add-NotionLogToFile -Level DEBUG
                    $output += [notion_comment]::ConvertfromObject($item)
                }
        
                "database"
                {
                    # https://developers.notion.com/reference/database
                    $output += [notion_database]::ConvertFromObject($item)
                    "Database" | Add-NotionLogToFile -Level DEBUG
                }
        
                "page"
                {
                    # https://developers.notion.com/reference/page
                    "Page" | Add-NotionLogToFile -Level DEBUG
                    $output += [notion_page]::ConvertfromObject($item)
                }
        
                "page_or_database"
                {  
                    "PageOrDatabase" | Add-NotionLogToFile -Level DEBUG
                }
        
                "property_item"
                {  
                    "PropertyItem" | Add-NotionLogToFile -Level DEBUG
                    $output += [PagePropertiesBase]::ConvertFromObject($item)
                }
        
                "user"
                {
                    # https://developers.notion.com/reference/user
                    "User" | Add-NotionLogToFile -Level DEBUG
                    $output += [notion_user]::ConvertFromObject($item)
                }
                Default
                {
                    "Object: $($item.object) not recognized" | Add-NotionLogToFile -Level WARN
                }
            }
            #Break
        }
    }
    end
    {
        return $output
    }
}
#EndRegion './Public/ConvertTo-NotionObject.ps1' 146
#Region './Public/Database/Add-NotionPageToDatabase.ps1' -1

function Add-NotionPageToDatabase {
    <#
    .SYNOPSIS
    Adds a new page to a Notion database.
    
    .DESCRIPTION
    The Add-NotionPageToDatabase function creates a new page in a specified Notion database.
    It is an alias for the New-NotionPage function and allows setting various properties,
    including the parent database, properties of the page, children blocks, icon, cover image, and title.
    
    .PARAMETER parent_database
    The parent database object of the page.
    
    .PARAMETER properties
    A hashtable containing the properties of the page.
    
    .PARAMETER children
    An array of blocks within this page.
    
    .PARAMETER icon
    The icon object of the page.
    
    .PARAMETER cover
    The cover image object of the page (see notion_file).
    
    .PARAMETER title
    The title of the page. This will overwrite the title-property if it exists.
    
    .OUTPUTS
    [notion_page]
    Returns the created Notion page object.
    
    .EXAMPLE
    PS> Add-NotionPageToDatabase -parent_database $database -properties $props -title "New Page"
    This example creates a new page in the specified Notion database with the given properties and title.
    #>
    # Alias for New-NotionPage
    [CmdletBinding()]
    [OutputType([notion_page])]
    param(
        [Parameter(HelpMessage = "The parent object of the page, if empty it will be created at the root (workspace) level")]
        [object] $parent_database,
        [Parameter(HelpMessage = "The properties of the page")]
        [hashtable] $properties = @{},
        [Parameter(HelpMessage = "An array of blocks within this page")]
        $children = @(),
        [Parameter(HelpMessage = "The icon of the page")]
        $icon,
        [Parameter(HelpMessage = "The cover image of the page (see notion_file)")]
        $cover,
        [Parameter(HelpMessage = "The title of the page. (Will overwrite the title-property if it exists)")]
        $title
    )

    $PSBoundParameters.Remove('parent_database') | Out-Null
    return (New-NotionPage @PSBoundParameters -parent_obj $parent_database)    
}
#EndRegion './Public/Database/Add-NotionPageToDatabase.ps1' 58
#Region './Public/Database/DatabaseProperties/Add-NotionDatabaseProperty.ps1' -1

function Add-NotionDatabaseProperty 
{
    <#
    .SYNOPSIS
    Adds a new property to a Notion database.

    .DESCRIPTION
    The `Add-NotionDatabaseProperty` function adds a specified property to a Notion database using the Notion API.
    You can specify the database ID, the property object, and the name of the property to be added.
    The function supports pipeline input for adding multiple properties in a single invocation.

    .PARAMETER DatabaseId
    The unique identifier of the Notion database where the property will be added. This parameter is mandatory.

    .PARAMETER property
    The property object to be added to the database. This parameter is mandatory and accepts input via the pipeline by property name.

    .PARAMETER PropertyName
    The name of the property to be added to the database. This parameter is mandatory and accepts input via the pipeline by property name.

    .OUTPUTS
    [notion_database]
    Returns a `notion_database` object representing the updated Notion database.

    .EXAMPLE
    
    Add-NotionDatabaseProperty -DatabaseId "12345abcde" -property @{ type = "title"; title = @{ text = @{ content = "New Title" } } } -PropertyName "Title"
    

    Adds a new title property named "Title" to the database with the ID `12345abcde`.

    .EXAMPLE
    
    @(
        @{ property = @{ type = "number"; number = @{ format = "number" } }; PropertyName = "Score" },
        @{ property = @{ type = "select"; select = @{ options = @(@{ name = "Option 1" }, @{ name = "Option 2" }) } }; PropertyName = "Category" }
    ) | Add-NotionDatabaseProperty -DatabaseId "12345abcde"
    

    Adds multiple properties (`Score` and `Category`) to the database with the ID `12345abcde` using pipeline input.

    .EXAMPLE
    
    $input = @{
        DatabaseId = "12345abcde"
        property = @{ type = "number"; number = @{ format = "number" } }
        PropertyName = "Score"
    }
    Add-NotionDatabaseProperty @input
    

    Adds a new number property named "Score" to the database with the ID `12345abcde`.

    .LINK
    https://developers.notion.com/reference/update-property-schema-object
    #>  
    [CmdletBinding()]
    [OutputType([notion_database])]
    param (
        [Parameter(Mandatory= $true, Position = 0,HelpMessage = "The ID of the database to add the property to")]
        [Alias("Id")]
        [string]$DatabaseId,
        [Parameter(Mandatory = $true, ValueFromPipelineByPropertyName=$true, HelpMessage = "The property object to add to the database")]
        [object]$property,
        [Parameter(Mandatory = $true, ValueFromPipelineByPropertyName=$true, HelpMessage = "The name of the property to add to the database")]
        [string]$PropertyName

    )
    begin{
        $properties = [notion_databaseproperties]::new()
    }
    process{
        $properties = $properties.AddProperty($property, $PropertyName)
    }
    end{
        $body = @{
            properties = $properties
        }
        $response = Invoke-NotionApiCall -method PATCH -uri "/databases/$DatabaseId" -body $body
        return [notion_database]::ConvertFromObject($response)
    }
    
}
#EndRegion './Public/Database/DatabaseProperties/Add-NotionDatabaseProperty.ps1' 84
#Region './Public/Database/DatabaseProperties/New-NotionDatabaseProperty.ps1' -1

function New-NotionDatabasePropertyObject{
    # eventualy implement
}
#EndRegion './Public/Database/DatabaseProperties/New-NotionDatabaseProperty.ps1' 4
#Region './Public/Database/DatabaseProperties/Remove-NotionDatabaseProperty.ps1' -1

function Remove-NotionDatabaseProperty 
{
    <#
    .SYNOPSIS
    Removes a specified property from a Notion database.
    
    .DESCRIPTION
    The Remove-NotionDatabaseProperty function removes a property from a Notion database by setting the property to null.
    It uses the Notion API to update the database.
    
    .PARAMETER DatabaseId
    The ID of the Notion database from which the property will be removed.
    
    .PARAMETER Property
    The ID or name of the property to remove from the Notion database.
    
    .EXAMPLE
    Remove-NotionDatabaseProperty -DatabaseId "12345678-1234-1234-1234-1234567890ab" -Property "PropertyName"
    
    This example removes the property named "PropertyName" from the specified Notion database.
    
    .EXAMPLE
    (Get-NotionDatabase -DatabaseId "12345678-1234-1234-1234-1234567890ab").Properties.Values.Name | Remove-NotionDatabaseProperty -DatabaseId "12345678-1234-1234-1234-1234567890ab"
    
    This example removes *all* properties by name from the specified Notion database using the pipeline. (Use with care!)
    
    .EXAMPLE
    (Get-NotionDatabase -DatabaseId "12345678-1234-1234-1234-1234567890ab").Properties.Values.Id | Remove-NotionDatabaseProperty -DatabaseId "12345678-1234-1234-1234-1234567890ab"
    
    This example removes *all* properties by Id from the specified Notion database using the pipeline. (Use with care!)
    
    .EXAMPLE
    @("PropertyName1", "PropertyName2") | Remove-NotionDatabaseProperty -DatabaseId "12345678-1234-1234-1234-1234567890ab"
    
    This example removes multiple properties from the specified Notion database using the pipeline.
    
    .LINK
    https://developers.notion.com/reference/update-property-schema-object
    
    #>

    [CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
    [OutputType([notion_database])]
    param (
        [Parameter(Mandatory = $true, Position = 0, HelpMessage = "The ID of the database to remove the property from")]
        [alias("Id")]
        [string]$DatabaseId,
        
        [Parameter(ValueFromPipeline = $true,Mandatory = $true, HelpMessage = "The id or name of the property to remove")]
        [string]$Property
    )

    begin{
        $properties = [notion_databaseproperties]::new()
    }
    process{
        $properties.Add("$Property", $null)
    }
    end{
        $body = @{
            properties = $properties
        }
    
        $response = Invoke-NotionApiCall -method PATCH -uri "/databases/$DatabaseId" -body $body
        return [notion_database]::ConvertFromObject($response)
    }
}
#EndRegion './Public/Database/DatabaseProperties/Remove-NotionDatabaseProperty.ps1' 68
#Region './Public/Database/Edit-NotionDatabase.ps1' -1

function Edit-NotionDatabase
{
    <#
    .SYNOPSIS
        Edit the properties, title, and description of an existing Notion database.
    
    .DESCRIPTION
        The Edit-NotionDatabase function allows you to edit the properties, title, and description of an existing Notion database.
    
    .PARAMETER DatabaseId
        The ID of the Notion database to be edited.
    
    .PARAMETER title
        An array of objects / a single object or string representing the title of the database. Each object can be a string or a rich_text object.
    
    .PARAMETER properties
        A hashtable representing the properties of the database. Use null values to remove properties.
    
    .PARAMETER description
        An array of objects / a single object or string representing the description of the database. Each object can be a string or a rich_text object.
    
    .OUTPUTS
        [notion_database]
        Returns the updated Notion database object.
    
    .EXAMPLE
        $title = "New Database Title"
        $properties = @{
            "Property1" = @{
                "name" = "New Property Name"
                "type" = "text"
            }
            "PropertyToRemove" = $null
        }
        $description = "This is a new description for the database."
        Edit-NotionDatabase -DatabaseId "your-database-id" -title $title -properties $properties -description $description

        This command overwrites the title and description and edits the properties of the specified Notion database.

    .EXAMPLE
        $database = Get-NotionDatabase -DatabaseId "your-database-id"
        $db_properties = $database.properties
        $db_properties.PropertyToRemove = $null
        Edit-NotionDatabase -DatabaseId "your-database-id" -properties $db_properties

        This command removes the "PropertyToRemove" property from the specified Notion database.
    
    .NOTES
        This function requires the Invoke-NotionAPICall function to make API calls to Notion.

    .LINK
        https://developers.notion.com/reference/patch-database
    #>
    [CmdletBinding()]
    [OutputType([notion_database])]
    param (
        [Alias("Id")]
        [Parameter(Mandatory = $true, Position = 0)]
        [string]$DatabaseId,
        [object[]] $title,
        [Parameter( HelpMessage = "The properties-objects of the database; value null for removing properties" )]
        [hashtable] $properties,
        [object[]] $description
    )
    $title = $title.foreach({
            if ($_ -is [rich_text])
            {
                $_
            }
            else
            {
                if ($_ -is [string])
                {
                    [rich_text_text]::new($_)
                }
                else
                {
                    [rich_text]::ConvertFromObject($_)
                }
            }
        })

    $description = $description.foreach({
            if ($_ -is [rich_text])
            {
                $_
            }
            else
            {
                if ($_ -is [string])
                {
                    [rich_text_text]::new($_)
                }
                else
                {
                    [rich_text]::ConvertFromObject($_)
                }
            }
        })
    if ($properties -isnot [notion_databaseproperties])
    {
        $properties = [notion_databaseproperties]::ConvertFromObject($properties)
    }

    $body = @{
    }
    if ($title)
    {
        $body.title = @($title | Remove-NullValuesFromObject)
    }
    if ($description)
    {
        $body.description = @($description | Remove-NullValuesFromObject)

    }
    if ($properties)
    {
        # here null values are not removed, because they are needed to remove properties
        $body.properties = $properties
    }

    $response = Invoke-NotionAPICall -Method PATCH -uri "/databases/$DatabaseId" -Body $body
    return [notion_database]::ConvertFromObject($response)
}
#EndRegion './Public/Database/Edit-NotionDatabase.ps1' 125
#Region './Public/Database/Get-NotionDatabase.ps1' -1

function Get-NotionDatabase
{
    <#
    .SYNOPSIS
    Retrieves a Notion database structure (not the data) by its ID.
    
    .DESCRIPTION
    The Get-NotionDatabase function calls the Notion API to retrieve a database using the provided DatabaseId.
    It sends a GET request to the Notion API and converts the response to a notion_database object.
    
    .PARAMETER DatabaseId
    The unique identifier of the Notion database to retrieve.
    
    .OUTPUTS
    notion_database
    
    .EXAMPLE
    PS C:\> Get-NotionDatabase -DatabaseId "your-database-id"
    PS C:\> Get-NotionDatabase -id "your-database-id"
    PS C:\> Get-NotionDatabase "your-database-id"
    
    This command retrieves the Notion database structure with the specified ID.

    #>
    [CmdletBinding()]
    [OutputType([notion_database])]
    param (
        [Alias("Id")]
        [Parameter(Mandatory = $true, Position = 0)]
        [string]$DatabaseId
    )
    
    $response = Invoke-NotionAPICall -Method GET -uri "/databases/$DatabaseId"
    return [notion_database]::ConvertFromObject($response)
}
#EndRegion './Public/Database/Get-NotionDatabase.ps1' 36
#Region './Public/Database/Move-NotionDatabaseToArchive.ps1' -1


function Move-NotionDatabaseToArchive 
{
    <#
        .SYNOPSIS
        Moves a Notion database to the archive.

        .DESCRIPTION
        The Move-NotionDatabaseToArchive function archives a specified Notion database by setting its archive property to true.
        This operation is confirmed by the user due to its high impact.

        .PARAMETER DatabaseId
        The ID of the database to archive. This parameter is mandatory.

        .INPUTS
        [string]

        .OUTPUTS
        [notion_database]

        .EXAMPLE
        PS C:\> Move-NotionDatabaseToArchive -DatabaseId "12345"
        This command archives the Notion database with the ID "12345".

        .NOTES
        This function uses the Invoke-NotionApiCall cmdlet to make a PATCH request to the Notion API.
        Attention: Only pages can be restored via the GUI. Databases can only be restored via the API.

        .LINK
        https://developers.notion.com/reference/update-a-database (archive=true)
#>
    [CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
    [OutputType([notion_database])]
    param (
        [Parameter(Mandatory = $true, HelpMessage = "The ID of the database to archive")]
        [Alias("Id")]
        [string]$DatabaseId
    )

    $body = @{
        archive = $true
    }
    $body = $body | Remove-NullValuesFromObject
    if ($PSCmdlet.ShouldProcess("Database $DatabaseId"))
    { 
        $response = Invoke-NotionApiCall -method PATCH -uri "/databases/$($DatabaseId)" -body $body
        return [notion_database]::ConvertFromObject($response)
    }
    else
    {
        return $null
    }
}
#EndRegion './Public/Database/Move-NotionDatabaseToArchive.ps1' 54
#Region './Public/Database/New-NotionDatabase.ps1' -1

function New-NotionDatabase
{
    <#
    .SYNOPSIS
    Creates a new Notion database.

    .DESCRIPTION
    The New-NotionDatabase function creates a new Notion database within the specified parent object, title, and properties.
    It converts the provided parameters to the appropriate types and makes an API call to create the database in Notion.

    .PARAMETER parent_obj
    The parent object of the page. If not provided, a default parent will be used.

    .PARAMETER title
    The title (or title object) of the database. Can be a string or an array of rich text objects.

    .PARAMETER properties
    The properties objects of the database. This parameter is mandatory.

    .OUTPUTS
    [notion_database]
    Returns a notion_database object representing the newly created database.

    .EXAMPLE
    $parent = @{
        type = "page_id"
        page_id = "12345678901234567890"
    }
    $title = "My New Database"
    $properties = @{
        Name = @{
            type = "title"
            title = @{}
        }
    }
    New-NotionDatabase -parent_obj $parent -title $title -properties $properties

    This command creates a new Notion database within the specified parent page, title, and properties.

    .NOTES
    This function requires the Invoke-NotionAPICall and Remove-NullValuesFromObject helper functions,
    as well as the notion_database, notion_parent, rich_text, rich_text_text, and notion_databaseproperties types.

    .LINK
    https://developers.notion.com/reference/create-a-database
    #>

    [CmdletBinding()]
    [OutputType([notion_database])]
    param (
        [Parameter(HelpMessage = "The parent object of the page")]
        [object] $parent_obj,
        [Parameter(HelpMessage = "The title(-object) of the database")]
        [object[]] $title,
        [Parameter(Mandatory = $true, HelpMessage = "The properties-objects of the database")]
        [hashtable] $properties
    )
    if ($null -eq $parent_obj)
    {
        #TODO: Implement a way to get the default parent
        #$parent = New-NotionPage # (in Workspace)
        throw "Parent object is required"
    }
    else
    {
        $parent_obj = [notion_parent]::ConvertFromObject($parent_obj)
    }
    $title = $title.foreach({
            if ($_ -is [rich_text])
            {
                $_
            }
            else
            {
                if ($_ -is [string])
                {
                    [rich_text_text]::new($_)
                }
                else
                {
                    [rich_text]::ConvertFromObject($_)
                }
            }
        })
    if ($properties -isnot [notion_databaseproperties])
    {
        $properties = [notion_databaseproperties]::ConvertFromObject($properties)
    }

    $body = @{
        parent     = $parent_obj
        properties = $properties
    }
    if ($title)
    {
        $body.title = $title
    }
    $body = $body | Remove-NullValuesFromObject
    $response = Invoke-NotionAPICall -Method POST -uri "/databases" -Body $body
    return [notion_database]::ConvertFromObject($response)
}
#EndRegion './Public/Database/New-NotionDatabase.ps1' 102
#Region './Public/Database/Remove-NotionDatabase.ps1' -1

function Remove-NotionDatabase
{
    <#
    .SYNOPSIS
    Moves a Notion database to the trash.

    .DESCRIPTION
    The `Remove-NotionDatabase` function marks a Notion database as "in trash" by sending
    a PATCH request to the Notion API. This effectively removes the database from active use.

    .PARAMETER DatabaseId
    The ID of the Notion database to move to the trash. This parameter is mandatory.

    .PARAMETER Confirm
    Prompts the user for confirmation before moving the database to the trash. The default is $true.

    .OUTPUTS
    [notion_database] | $null
    Returns a `notion_database` object representing the trashed database. Returns $null if the operation is cancelled.

    .EXAMPLE
    Remove-NotionDatabase -DatabaseId "12345678-abcd-1234-efgh-56789ijklmn0" -Confirm:$false

    This example moves the database with the specified ID to the trash.

    .NOTES
    Requires the `Invoke-NotionAPICall` function and appropriate API authentication to be configured.
    This function does not permanently delete the database but marks it as "in trash."
    Ensure you have appropriate permissions to modify the database in Notion.
    
    Attention: Only pages can be restored via the GUI. Databases can only be restored via the API.

    .LINK
    https://developers.notion.com/reference/database (in_trash = true)
    https://developers.notion.com/reference/update-a-database
    #>

    [CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
    [OutputType([notion_database])]
    param (
        [Parameter(Mandatory = $true, HelpMessage = "The ID of the database to remove")]
        [Alias("Id")]
        [string]$DatabaseId
    )

    $body = @{
        in_trash = $true
    }
    $body = $body | Remove-NullValuesFromObject
    if ($PSCmdlet.ShouldProcess("Database $DatabaseId", "Move to trash"))
    { 
        $response = Invoke-NotionAPICall -Method PATCH -uri "/databases/$($DatabaseId)" -Body $body
        return [notion_database]::ConvertFromObject($response)
    }
    else
    {
        return $null
    }

}
#EndRegion './Public/Database/Remove-NotionDatabase.ps1' 61
#Region './Public/Database/Restore-NotionDatabase.ps1' -1

function Restore-NotionDatabase
{
    <#
    .SYNOPSIS
    Restores a Notion database from the trash.

    .DESCRIPTION
    The `Restore-NotionDatabase` function marks a Notion database as "not in trash" by sending
    a PATCH request to the Notion API. This allows a previously trashed database to become active again.

    .PARAMETER DatabaseId
    The ID of the Notion database to restore. This parameter is mandatory.

    .OUTPUTS
    [notion_database]
    Returns a `notion_database` object representing the restored database.

    .EXAMPLE
    Restore-NotionDatabase -DatabaseId "12345678-abcd-1234-efgh-56789ijklmn0"

    This example restores the database with the specified ID from the trash.

    .NOTES
    Requires the `Invoke-NotionAPICall` function and appropriate API authentication to be configured.
    Ensure you have the necessary permissions to modify the database in Notion.

    .LINK
    https://developers.notion.com/reference/update-a-database
    #>

    [OutputType([notion_database])]
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, HelpMessage = "The ID of the database to restore")]
        [Alias("Id")]
        [string]$DatabaseId   
    )

    $body = @{
        in_trash = $false
        archived = $false
    }
    $body = $body | Remove-NullValuesFromObject

    $response = Invoke-NotionAPICall -Method PATCH -uri "/databases/$($DatabaseId)" -Body $body
    return [notion_database]::ConvertFromObject($response)
}
#EndRegion './Public/Database/Restore-NotionDatabase.ps1' 48
#Region './Public/Disconnect-Notion.ps1' -1

function Disconnect-Notion
{
    <#
    .SYNOPSIS
    Disconnects from the Notion API by clearing the global variables.
    
    .DESCRIPTION
    The Disconnect-Notion function is used to disconnect from the Notion API. It clears the global variables used to store the connection information. The function uses ShouldProcess to confirm the action with the user.
  
    .PARAMETER Confirm
    Prompts the user to confirm the disconnection from the Notion API.
    
    .EXAMPLE
    Disconnect-Notion
    
    Prompts the user to confirm the disconnection from the Notion API and clears the connection information if confirmed.
    
    #>
    [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'High')]
    param ()
    
    if ($PSCmdlet.ShouldProcess("Notion API connection"))
    {
        Remove-Variable -Name NotionAPIKey -Scope Global -ErrorAction SilentlyContinue
        Remove-Variable -Name NotionApiUri -Scope Global -ErrorAction SilentlyContinue
        Remove-Variable -Name NotionAPIVersion -Scope Global -ErrorAction SilentlyContinue
        Write-Host "Disconnected from the Notion API." -ForegroundColor Green
    }
    else
    {
        Write-Host "Disconnection from the Notion API was cancelled." -ForegroundColor Yellow
    }
}
#EndRegion './Public/Disconnect-Notion.ps1' 34
#Region './Public/Invoke-NotionApiCall.ps1' -1


function Invoke-NotionApiCall
{
    <#
    .SYNOPSIS
        Invokes an API call to Notion.
    
    .DESCRIPTION
        This function is used to make API calls to Notion. It supports various HTTP methods such as GET, POST, PUT, DELETE, and PATCH. It also allows you to specify the API key, API version, and other parameters required for the API call.
    
    .PARAMETER uri
        The URI to Notion.
    
    .PARAMETER APIKey
        The API key to authenticate the API call. (Optional)
    
    .PARAMETER APIVersion
        The version of the Notion API. (Optional)
    
    .PARAMETER method
        The HTTP method to use for the API call. Valid values are "GET", "POST", "PUT", "DELETE", and "PATCH".
    
    .PARAMETER body
        The body of the API request. (Optional)
    
    .PARAMETER fileName
        The name of the log file to write the API call details. (Optional)
    
    .PARAMETER pageSize
        The number of items from the full list desired in the response. Maximum: 100. (Default: 100)
    
    .PARAMETER first
        The number of items returned from the first page in the response. Maximum: 100.
    
    .EXAMPLE
        Invoke-NotionApiCall -uri "https://api.notion.com/v1/databases" -APIKey "YOUR_API_KEY" -APIVersion "2021-05-13" -method "GET" -pageSize 50
    
        This example invokes a GET API call to the Notion API to retrieve a list of databases. It specifies the API key, API version, and page size of 50.
    
    .OUTPUTS
        The output of the API call, which can be an array of results or null if an error occurs.
    
    .NOTES
        This function requires the "Invoke-RestMethod" cmdlet to be available.
    
    .LINK
        https://www.notion.com/developers/api-reference
        Notion API Reference
    #>
    
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $false, HelpMessage = "The URI to Notion", Position = 0)]
        [string]$uri,
        [Parameter(Mandatory = $false, HelpMessage = "The API key to authenticate the API call")]
        [securestring]$APIKey,
        [Parameter(Mandatory = $false, HelpMessage = "The version of the Notion API")]
        [String]$APIVersion = $global:NotionAPIVersion,
        [Parameter(Mandatory = $false, HelpMessage = "The HTTP method to use for the API call")]
        [ValidateSet("GET", "POST", "PUT", "DELETE", "PATCH") ]
        $method = "GET",
        [Parameter(ParameterSetName = "Body")]
        [System.Object]$body,
        $fileName,
        [Parameter(HelpMessage = "The number of items from the full list desired in the response. Maximum: 100")]
        [ValidateRange(1, 100)]
        [int]$pageSize,
        [Parameter(HelpMessage = "The number of items returned from the first page in the response")]
        $first
    )


    Process
    {
        if ((-not $Global:NotionAPIKey) -and (-not $APIKey))
        {
            $ErrorRecord = New-Object System.Management.Automation.ErrorRecord (
                [System.Management.Automation.RuntimeException]::new("API key is not set. Please use Connect-Notion to set the API key."),
                "APIKeyNotSet",
                [System.Management.Automation.ErrorCategory]::InvalidData,
                $PSBoundParameters
            )

            throw $ErrorRecord
        }
        $APIKey ??= $Global:NotionAPIKey
        $queryParameters = @{}
        if ($PSBoundParameters.ContainsKey("pageSize") -and $pageSize -gt 0)
        {
            $queryParameters["page_size"] = $pageSize
        }
        if ($uri -notlike "$global:NotionApiUri*")
        {
            $uri = $global:NotionApiUri + $uri
        }
        $Params = @{
            "URI"     = $uri
            "Headers" = @{
                "Authorization"  = "Bearer {0}" -F ($APIKey | ConvertFrom-SecureString -AsPlainText)
                "Accept"         = "application/json"
                "Content-type"   = "application/json"
                "Notion-Version" = "{0}" -F $APIVersion
            }
            "Method"  = $method
        }
        if ($body)
        {
            $Params.Add("Body", ($body | ConvertTo-Json -EnumsAsStrings -Depth 20))
        }
        # https://developers.notion.com/reference/intro
        # Parameter location varies by endpoint
        # GET requests accept parameters in the query string.
        # POST requests receive parameters in the request body.

        "Request params:", $Params | Add-NotionLogToFile -filename $fileName -level DEBUG
        :loop while ($true)
        {
            Try
            {
                $output = @()
                if ($method -in @("GET", "POST"))
                {                   
                    # https://developers.notion.com/reference/intro#pagination
                    $SupportPagingPatterns = @(
                        "/v1/users", 
                        "/v1/blocks/.*/children",
                        "/v1/comments",
                        "/v1/pages/.*/properties/.*", 
                        "/v1/databases/.*/query", 
                        "/v1/search"
                    )
    
                    # Extract the endpoint part of the URL
                    $endpoint = $uri -replace '^https://[^/]+', ''
    
                    # Filter the endpoint based on the defined patterns
                    $filteredEndpoint = $SupportPagingPatterns.Where( { $endpoint -match $_ })
    
                    # Output the result if it matches any of the patterns
                    if ($filteredEndpoint )
                    {
                        Write-Debug "Paging: Endpoint: $endpoint supports paging using page_size $first"
                        if (-not $queryParameters.page_size -and $first -gt 0)
                        {
                            $queryParameters.Add("page_size", $first)
                        }
                    }
                    else
                    {
                        Write-Debug "Paging: Endpoint $endpoint doesn't support paging"
                        # remove page_size from queryParameters
                        try
                        {
                            $queryParameters.Remove("page_size")
                        }
                        catch
                        {
                            <#Do this if a terminating exception happens#>
                            $error.Clear()
                        }
                    }
                }
                else
                {
                    Write-Debug "Paging: Method $method doesn't support paging"
                    # remove page_size from queryParameters
                    try
                    {
                        $queryParameters.Remove("page_size")
                    }
                    catch
                    {
                        $error.Clear()
                    }
                }
                if ($first -and $queryParameters.page_size -and ($first -lt ($pageSize + $output.count)))
                {
                    $queryParameters.page_size = $first
                }
                # Add query parameters to the URI
                if ($method -eq "GET")
                {
                    $Params["URI"] = $uri 
                    if ($queryParameters.Count -gt 0)
                    {
                        $Params["URI"] += "?" + ($queryParameters.GetEnumerator() | ForEach-Object { "{0}={1}" -f $_.Key, $_.Value }) -join "&"
                    }
                }
                # Add parameter to the body
                elseif ($method -eq "POST")
                {
                    $Params["URI"] = $uri
                    foreach ($key in $queryParameters.Keys)
                    {
                        $value = $queryParameters[$key]
                        $body | Add-Member -MemberType NoteProperty -Name $key -Value $value -Force
                    }
                    Write-Debug "Body: $($body | ConvertTo-Json -EnumsAsStrings -Depth 20)"
                    $Params["Body"] = ($body | ConvertTo-Json -EnumsAsStrings -Depth 20)
                }
                Write-Debug "$method $($Params["URI"])"
                $content = Invoke-RestMethod @Params
                # $content.results only exists if the response is paginated, otherwise $content is the result
                if (($content.object -eq "list") -and ($content.results))
                {
                    Write-Debug "Paging: Found $($content.results.count) items"
                    $output += $content.results
                }
                else
                {
                    Write-Debug "Paging: Result is not paginated, object type: $($content.object)"
                    $output += $content
                }
                # content.has_more is only available if the endpoint supports pagination
                if (($content.has_more -eq $true) -and ($output.count -lt $first))
                {
                    $queryParameters | Add-Member -MemberType NoteProperty -Name "start_cursor" -Value $content.next_cursor -Force
                    $Params["URI"] = $uri
                    continue loop
                }
                return $output
                # Convert the output to Notion objects
                # return $output | ConvertTo-NotionObject
            }
            catch [Microsoft.PowerShell.Commands.HttpResponseException]
            {
                $message = ($_.Errordetails.message | ConvertFrom-Json)
                $e = @{
                    Status     = $message.status
                    Code       = $message.code
                    Message    = $message.message
                    Command    = $_.InvocationInfo.MyCommand
                    Method     = $_.TargetObject.Method
                    RequestUri = $_.TargetObject.RequestUri
                    Headers    = $_.TargetObject.Headers
                }
                #$e | Add-NotionLogToFile -filename $fileName -level ERROR
                $outputParams = $Params.Clone()
                $outputParams.Headers.Authorization = "Bearer *****"
                "InvokeParams", $outputParams | Add-NotionLogToFile -filename $fileName -level ERROR
                "Body", $outputParams.body | Add-NotionLogToFile -filename $fileName -level ERROR
                switch -wildcard ($e.Status)
                {
                    400
                    {
                        Write-Error "HTTP error 400: $($message.code) - $($message.message)" -TargetObject $e -Category InvalidData
                        # switch ($e.code)
                        # {
                        # "invalid_json"
                        # {
                        # Write-Error "HTTP error 400: Error parsing JSON body."
                        # }
                        # "invalid_request_url"
                        # {
                        # Write-Error "HTTP error 400: Invalid request URL"
                        # }
                        # "invalid_request"
                        # {
                        # Write-Error "HTTP error 400: Unsupported request: <request name>."
                        # }
                        # "invalid_grant"
                        # {
                        # Write-Error "HTTP error 400: Invalid code: this code has been revoked."
                        # }
                        # "validation_error"
                        # {
                        # Write-Error "HTTP error 400: Body failed validation: $message"
                        # }
                        # "missing_version"
                        # {
                        # Write-Error "HTTP error 400: Notion-Version header failed validation: Notion-Version header should be defined, instead was undefined."
                        # }
                        # }
                        break
                    }
                    401
                    {
                        Write-Error "HTTP error 401: API token is invalid."
                        break
                    }
                    403
                    {
                        Write-Error "HTTP error 403: API token does not have access to this resource."
                        break
                    }
                    404
                    {
                        Write-Error "HTTP error 404: Could not find object. Make sure the relevant pages and databases are shared with your integration."
                        break
                    }
                    409
                    {
                        Write-Error "HTTP error 409: Conflict occurred while saving. Please try again."
                        break
                    }
                    429
                    {
                        Write-Error "HTTP error 429: Rate limit exceeded. Please wait and retry."
                        if (($e.Headers.Contains("Retry-After")) -and ($e.Headers.GetValues("Retry-After")))
                        {
                            #get the first value of the array (is provided as string array)
                            Write-Warning "Sleeping for $([int]$e.headers.GetValues("Retry-After")[0]) sec as to many api calls"
                            Start-Sleep ([int]$e.Headers.GetValues("Retry-After")[0])
                        }
                        else
                        {
                            Write-Warning "Sleeping for 60 sec as to many api calls"
                            Start-Sleep 60
                        }
                        $error.Clear()
                        continue loop
                    }
                    500
                    {
                        Write-Error "HTTP error 500: Internal server error. Unexpected error occurred."
                        break
                    }
                    502
                    {
                        Write-Error "HTTP error 502: Bad gateway."
                        break
                    }
                    503
                    {
                        switch ($e.code)
                        {
                            "service_unavailable"
                            {
                                Write-Error "HTTP error 503: service_unavailable - Notion is unavailable, please try again later."
                            }
                            "database_connection_unavailable"
                            {
                                Write-Error "HTTP error 503: database_connection_unavailable - Database is unavailable, please try again later."
                            }
                            "gateway_timeout"
                            {
                                Write-Error "HTTP error 503: gateway_timeout - Gateway timeout."
                            }
                        }
                    }
                    default
                    {
                        Write-Error "Something went wrong with your request"
                    }
                }
                $error.Clear()
                return $null
            }
            catch
            {
                "Invoke-NotionApiCall - Error in Invoke-RestMethod:", $error | Add-NotionLogToFile -filename $fileName -level ERROR
                $error.clear()
                return $null
            }
        }
    }
}
#EndRegion './Public/Invoke-NotionApiCall.ps1' 358
#Region './Public/New-NotionHeader.ps1' -1

<#
.SYNOPSIS
Creates a new Notion header.

.DESCRIPTION
The New-NotionHeader function creates a new header for a Notion page with specified text, color, level, and toggleable option.

.PARAMETER Text
The text of the header. This parameter is mandatory.

.PARAMETER Color
The color of the header. This parameter is optional and defaults to "default".

.PARAMETER Level
The level of the header (1-3). This parameter is mandatory.

.PARAMETER is_toggleable
Specifies if the header is toggleable. This parameter is optional.

.EXAMPLE
PS> New-NotionHeader -Text "My Header" -Level 1

Creates a level 1 header with the text "My Header" and default color.

.EXAMPLE
PS> New-NotionHeader -Text "My Header" -Color "blue" -Level 2 -is_toggleable $true

Creates a level 2 header with the text "My Header", blue color, and toggleable option enabled.

#>
function New-NotionHeader

{
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, HelpMessage = "Text of the Header")]
        [string] $Text,
        [Parameter(Mandatory = $false, HelpMessage = "Color of the Header")]
        [notion_color] $Color = "default",
        [Parameter(Mandatory = $true, HelpMessage = "Level of the Header (1-3)")]
        [int] $Level,
        [Parameter(Mandatory = $false, HelpMessage = "Is the Header toggleable")]
        [boolean] $is_toggleable 
    )
    
    begin
    {
    }
    process
    {
        $Header = [Heading]::new($level, $text, $color, $is_toggleable)
        return $Header
    }
    end
    {
    }
}
#EndRegion './Public/New-NotionHeader.ps1' 58
#Region './Public/Page/Get-NotionPage.ps1' -1

function Get-NotionPage
{
    <#
    .SYNOPSIS
        Retrieves properties of a Notion page using the Notion API.
    
    .DESCRIPTION
        The `Get-NotionPage` function retrieves a specified Notion page by making a GET request
        to the Notion API's `/v1/pages/{page_id}` endpoint, utilizing the `Invoke-NotionApiCall` function.
    
    .PARAMETER PageId
        The unique identifier of the Notion page. This is a required parameter.

    .PARAMETER Raw
        If this switch is enabled, the raw response from the API call will be returned.
    
    .PARAMETER maxDepth
        The maximum depth of subblocks objects. The default is 5.
    
    .EXAMPLE
        $pageId = "d5f1d1a5-7b16-4c2a-a2a6-7d43574a1787"
        Get-NotionPage -PageId $pageId
    
        This example retrieves the page with the specified ID.
    
    .NOTES
        - Ensure that the Notion API integration has access to the page.
        - The API token and version are handled within the `Invoke-NotionApiCall` function.

        - If you need the page content use [Get-NotionPageChildren](./Get-NotionPageChildren.ps1) to get the children of the page.
    
    .LINK
        https://developers.notion.com/reference/retrieve-a-page-property-item
    #>
    [CmdletBinding()]
    [OutputType([notion_page])]
    param (
        [Parameter(Mandatory = $true)]
        [Alias("Id")]
        [string]$PageId,
        [Parameter(ParameterSetName = "Class")]
        [int]$maxDepth = 5
    )

    # Construct the API endpoint URL
    $url = "/pages/$PageId"

    # Make the API call using the Invoke-NotionApiCall function
    $response = Invoke-NotionApiCall -uri $url -method "GET"

    # Return the response to the caller
    $pageObj = [notion_page]::ConvertFromObject($response)
    return $pageObj
}
#EndRegion './Public/Page/Get-NotionPage.ps1' 55
#Region './Public/Page/Get-NotionPageChildren.ps1' -1

function Get-NotionPageChildren 
{
    <#
    .SYNOPSIS
    Retrieves the children blocks of a Notion page.

    .DESCRIPTION
    The `Get-NotionPageChildren` function acts as a wrapper for the `Get-NotionBlockChildren` function. It retrieves all child blocks associated with a specific Notion page, given its ID.

    .PARAMETER PageId
    The unique identifier of the Notion page whose children are to be retrieved. This parameter is mandatory.

    .OUTPUTS
    [notion_block[]]
    Returns an array of `notion_block` objects representing the child blocks of the specified Notion page.

    .NOTES
    - This function simplifies the process of retrieving child blocks by accepting a page ID and internally calling the `Get-NotionBlockChildren` function.
    - Ensure that the Notion API is properly configured and authorized for use.

    .EXAMPLE
    Get-NotionPageChildren -PageId "12345abcde"

    Retrieves the child blocks of the Notion page with the ID `12345abcde`.

    .EXAMPLE
    "67890fghij", "11223klmno" | ForEach-Object { Get-NotionPageChildren -PageId $_ }

    Retrieves the child blocks for multiple Notion pages with IDs `67890fghij` and `11223klmno`.

    .EXAMPLE
    $pageIds = @("12345abcde", "67890fghij")
    $pageIds | Get-NotionPageChildren

    Uses pipeline input to retrieve the child blocks for multiple Notion pages.

    .LINK
    https://developers.notion.com/reference/get-block-children
    
    #>

    [CmdletBinding()]
    [OutputType([notion_block[]])]
    param (
        [Parameter(Mandatory = $true, Position=0, HelpMessage = "The ID of the page to get the children from")]
        [Alias("Id")]
        [string]$PageId
    )
    return (Get-NotionBlockChildren -BlockId $PageId)
}
#EndRegion './Public/Page/Get-NotionPageChildren.ps1' 51
#Region './Public/Page/Move-NotionPageToArchive.ps1' -1

function Move-NotionPageToArchive 
{
    <#
    .SYNOPSIS
    Moves a Notion page to the archive.
    
    .DESCRIPTION
    The Move-NotionPageToArchive function moves a specified Notion page to the archive by setting the 'archived' property to true.
    
    .PARAMETER PageId
    The ID of the page to remove. This parameter is mandatory.
    
    .EXAMPLE
    Move-NotionPageToArchive -PageId "12345678-90ab-cdef-1234-567890abcdef"
    This example moves the Notion page https://www.notion.so/12345678-90ab-cdef-1234-567890abcdef with the specified ID to the trash.
    
    .NOTES
    This function supports ShouldProcess for safety, allowing you to confirm the action before it is performed.
    The ConfirmImpact is set to 'High' due to the potential impact of removing a page.
    
    #>
        [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'High')]
        [OutputType([notion_page])]
        param(
            [Parameter(Mandatory = $true, HelpMessage = "The ID of the page to archive")]
            [string]$PageId
        )
    
        $body = @{
            archived = $true
        }
        $body = $body | Remove-NullValuesFromObject
        if ($PSCmdlet.ShouldProcess($PageId)) {
            $response = Invoke-NotionApiCall -method PATCH -uri "/pages/$PageId" -body $body
            return [notion_page]::ConvertFromObject($response)
        } else {
            return $null
        }
    }
    
#EndRegion './Public/Page/Move-NotionPageToArchive.ps1' 41
#Region './Public/Page/New-NotionPage.ps1' -1

function New-NotionPage
{
    <#
    .SYNOPSIS
        Creates a new Notion page.

    .DESCRIPTION
        The New-NotionPage function creates a new Notion page with specified properties, children blocks, icon, and cover image.
        If no parent object is provided, the page will be created at the root (workspace) level.

    .PARAMETER parent_obj
        The parent object of the page. If empty, the page will be created at the root (workspace) level.

    .PARAMETER properties
        The properties of the page. This should be a hashtable.

    .PARAMETER children
        An array of blocks within this page.

    .PARAMETER icon
        The icon of the page.

    .PARAMETER cover
        The cover image of the page (see notion_file).

    .PARAMETER title
        The title of the page. This will overwrite the title property if it exists.

    .EXAMPLE
        New-NotionPage -parent_obj $parent -properties @{Property1="Value1"} -title "New Page Title"

    .NOTES
        This function requires the Invoke-NotionApiCall function to be defined.

    .LINK
        https://developers.notion.com/reference/post-page
    #>
    [CmdletBinding()]
    [OutputType([notion_page])]
    param (
        [Parameter(HelpMessage = "The parent object of the page, if empty it will be created at the root (workspace) level")]
        [object] $parent_obj,
        [Parameter(HelpMessage = "The properties of the page")]
        [hashtable] $properties = @{},
        [Parameter(HelpMessage = "An array of blocks within this page")]
        $children = @(),
        [Parameter(HelpMessage = "The icon of the page")]
        $icon,
        [Parameter(HelpMessage = "The cover image of the page (see notion_file)")]
        $cover,
        [Parameter(HelpMessage = "The title of the page. (Will overwrite the title-property if it exists)")]
        $title
    )
    try
    {
        $body = @{}
    
        # if $parent_obj is not provided, add page to Workspace
        $parent_obj ??= [notion_workspace_parent]::new()

        if ($parent_obj -isnot [notion_parent])
        {
            $parent_obj = [notion_parent]::ConvertFromObject($parent_obj)
        }
        $body.Add("parent", $parent_obj)

        if (($parent.Type -eq "page_id") -and ($properties -gt 0))
        {
            Write-Warning "the new page is a child of an existing page, title is the only valid property!"
            $properties = @{}
        }

        if (($properties.count -gt 0) -and ($properties -isnot [notion_pageproperties]))
        {
            $properties = [notion_pageproperties]::ConvertFromObject($properties)
        }

        if ($title -and (-not $properties.Title))
        {
            #BUG: [notion_title_page_property]::new($title) geht so nicht
            $titleobj = [rich_text]::new([rich_text_type]::text, [annotation]::new())
            $titleobj.plain_text = $title
            #$properties.Add("Title", [notion_title_page_property]::new($title))
            $properties.Add("Title", $titleobj)
        }
        elseif ($title -and $properties.Title)
        {
            <# Action when this condition is true #>
            $properties.Title = [notion_title_page_property]::new($title)
        }
        $body.Add("properties", $properties)

        if ($children)
        {
            $childrenList = $children.ForEach({
                    if ($_ -is [notion_block])
                    {
                        $_
                    }
                    else
                    {
                        [notion_block]::ConvertFromObject($_)
                    }
                })
            $body.Add("children", $childrenList)
        }
    
        if ($icon)
        {
            if ($icon -isnot [notion_icon])
            {
                $icon = [notion_icon]::ConvertToObject($icon)
            }
            $body.Add("icon", [notion_icon]::ConvertFromObject($icon))
        }

        if ($cover)
        {
            if ($cover -isnot [notion_file])
            {
                $cover = [notion_file]::ConvertToObject($cover)
            }
            $body.Add("cover", [notion_file]::ConvertFromObject($cover))
        }
    }
    catch
    {
        Write-Host -ForegroundColor Green "TS"
        Write-Host -ForegroundColor Cyan $properties
        Write-Error $_.Exception.Message
        Write-Host -ForegroundColor Magenta ($body | conertto-json)
        Write-Host -ForegroundColor Green "--"
    }
    try
    {
        $body = $body | Remove-NullValuesFromObject
        $response = Invoke-NotionAPICall -Method POST -uri "/pages" -Body $body
        return [notion_page]::ConvertFromObject($response)
    }
    catch
    {
        Write-Error $_.Exception.Message
    }
}
#EndRegion './Public/Page/New-NotionPage.ps1' 145
#Region './Public/Page/PageProperties/Get-NotionPageProperty.ps1' -1

function Get-NotionPageProperty
{
    <#
    .SYNOPSIS
    Retrieves the properties of a specified Notion page.

    .DESCRIPTION
    The `Get-NotionPageProperty` function fetches the properties of a Notion page
    by making a GET request to the Notion API. The properties are returned as a
    `notion_pageproperties` object for further use.

    .PARAMETER PageId
    The unique identifier of the Notion page whose properties are to be retrieved. This parameter is mandatory.

    .PARAMETER PropertyID

    The unique identifier of the Notion page property to retrieve.

    .OUTPUTS
    [notion_pageproperties]
    Returns a `notion_pageproperties` object containing the properties of the specified Notion page.

    .EXAMPLE
    Get-NotionPageProperty -PageId "12345678-abcd-1234-efgh-56789ijklmn0"

    This example retrieves the properties of the Notion page with the specified ID.

    .EXAMPLE
    Get-NotionPageProperty -PageId "12345678-abcd-1234-efgh-56789ijklmn0" -PropertyID "6757567-98568907657-4435235"

    This example retrieves the specified property of the Notion page with the specified ID.

    .NOTES
    Requires the `Invoke-NotionApiCall` function and appropriate API authentication to be configured.
    Ensure you have access permissions for the specified page in Notion.

    .LINK
    https://developers.notion.com/reference/retrieve-a-page-property#rollup-properties
    #>

    [CmdletBinding()]
    [OutputType([PagePropertiesBase])]
    param (
        [Parameter(Mandatory = $true, Position = 0, HelpMessage = "The ID of the Notion page to retrieve properties for.")]
        [Alias("Id")]
        [string]$PageId,
        [Parameter(Mandatory = $true, Position = 1, HelpMessage = "The ID of the Notion page property to retrieve.")]
        [string]$PropertyID
    )

    $PropertiesRaw = Invoke-NotionApiCall -Uri "/pages/$PageId/properties/$PropertyID" -Method GET
    if($PropertiesRaw.object -eq "property_item")
    {
        $converted = [PagePropertiesBase]::ConvertFromObject($PropertiesRaw)
        return $converted
    }
    elseif($PropertiesRaw.object -eq "lists")
    {
        $converted = $PropertiesRaw.results.foreach({[PagePropertiesBase]::ConvertFromObject($_)})
        #TODO: implement pagination
        return $converted
    }
    else{
        Write-Error "Unknown object type: $($PropertiesRaw.object)" -Category InvalidData -RecommendedAction "Check the object type"
    }
    return $null
}
#EndRegion './Public/Page/PageProperties/Get-NotionPageProperty.ps1' 68
#Region './Public/Page/PageProperties/Update-NotionPageProperty.ps1' -1

function Update-NotionPageProperty
{
        <#
    .SYNOPSIS
        Updates properties of a Notion page.

    .DESCRIPTION
        The Update-NotionPageProperty function updates various properties of a Notion page, such as title, properties, icon, and cover image.
        It can also archive or delete the page.

    .PARAMETER PageId
        The ID of the page to update. This parameter is mandatory.

    .PARAMETER title
        The title of the page. This can be a string or a rich_text object.

    .PARAMETER properties
        The properties of the page. This should be a hashtable.

    .PARAMETER in_trash
        Set to true to delete the page. Set to false to restore the page.

    .PARAMETER archived
        Set to true to archive the page. Set to false to unarchive the page.

    .PARAMETER icon
        A page icon for the page. Supported types are external file object or emoji object.

    .PARAMETER cover
        A cover image for the page. Only external file objects are supported.

    .EXAMPLE
        Update-NotionPageProperty -PageId "some-page-id" -title "New Title" -properties @{Property1="Value1"} -archived $true

    .NOTES
        This function requires the Invoke-NotionApiCall function to be defined.
    .LINK
        https://developers.notion.com/reference/patch-page
    #>
    [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact = 'Medium')]
    [OutputType([notion_page])]
    param(
        [Parameter(Mandatory = $true, HelpMessage = "The ID of the page to remove")]
        [Alias("Id")]
        [string]$PageId,
        [Parameter(HelpMessage = "The title(-object) of the database")]
        [object[]] $title,
        [Parameter(HelpMessage = "The properties of the page")]
        [hashtable] $properties = @{},
        [Parameter(HelpMessage = "Set to true to delete the page. Set to false to restore the page.")]
        [bool]$in_trash = $false,
        [Parameter(HelpMessage = "Set to true to archive the page. Set to false to unarchive the page.")]
        [bool]$archived,
        [Parameter(HelpMessage = "A page icon for the page. Supported types are external file object or emoji object")]
        [notion_icon]$icon,
        [Parameter(HelpMessage = "A cover image for the page. Only external file objects are supported.")]
        [notion_file]$cover
    )

    $title = $title.foreach({
            if ($_ -is [rich_text])
            {
                $_
            }
            else
            {
                if ($_ -is [string])
                {
                    [rich_text_text]::new($_)
                }
                else
                {
                    [rich_text]::ConvertFromObject($_)
                }
            }
        })
        
    $body = @{
    }
    if ($title)
    {
        $body.title = @($title | Remove-NullValuesFromObject)
    }
    if($in_trash)
    {
        $body.archived = $in_trash
    }
    if($archived)
    {
        $body.archived = $archived
    }
    if($archived -and $in_trash)
    {
        Write-Error "You can't archive and delete a page at the same time" -Category InvalidOperation -RecommendedAction "Check the parameters"
        return $null
    }
    if ($icon)
    {
        if ($icon -isnot [notion_icon])
        {
            $icon = [notion_icon]::ConvertToObject($icon)
        }
        $body.Add("icon", [notion_icon]::ConvertFromObject($icon))
    }

    if ($cover)
    {
        if ($cover -isnot [notion_file])
        {
            $cover = [notion_file]::ConvertToObject($cover)
        }
        $body.Add("cover", [notion_file]::ConvertFromObject($cover))
    }
    
    if ($properties)
    {
        # here null values are not removed, because they are needed to remove properties
        $body.properties = $properties
    }

    if ($PSCmdlet.ShouldProcess("$PageId"))
    {
        $response = Invoke-NotionApiCall -method PATCH -uri "/pages/$PageId" -body $body
        return [notion_page]::ConvertFromObject($response)
    }
    else{
        Write-Debug "Operation cancelled by user"
        return $null
    }


}
#EndRegion './Public/Page/PageProperties/Update-NotionPageProperty.ps1' 133
#Region './Public/Page/Remove-NotionPage.ps1' -1

function Remove-NotionPage {
<#
.SYNOPSIS
Removes a Notion page by moving it to the trash.

.DESCRIPTION
The Remove-NotionPage function moves a specified Notion page to the trash by setting the 'in_trash' property to true.

.PARAMETER PageId
The ID of the page to remove. This parameter is mandatory.

.EXAMPLE
Remove-NotionPage -PageId "12345678-90ab-cdef-1234-567890abcdef"
This example moves the Notion page https://www.notion.so/12345678-90ab-cdef-1234-567890abcdef with the specified ID to the trash.

.NOTES
This function supports ShouldProcess for safety, allowing you to confirm the action before it is performed.
The ConfirmImpact is set to 'High' due to the potential impact of removing a page.

#>
    [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'High')]
    [OutputType([notion_page])]
    param(
        [Parameter(Mandatory = $true, Position=0, HelpMessage = "The ID of the page to remove")]
        [Alias("Id")]
        [string]$PageId
    )

    $body = @{
        in_trash = $true
    }
    $body = $body | Remove-NullValuesFromObject
    if ($PSCmdlet.ShouldProcess($PageId)) {
        $response = Invoke-NotionApiCall -method PATCH -uri "/pages/$PageId" -body $body
        return [notion_page]::ConvertFromObject($response)
    } else {
        return $null
    }
}
#EndRegion './Public/Page/Remove-NotionPage.ps1' 40
#Region './Public/Page/Restore-NotionPage.ps1' -1

function Restore-NotionPage {
    <#
    .SYNOPSIS
    Restores a Notion page by removing it from the trash or archive.

    .DESCRIPTION
    The `Restore-NotionPage` function restores a Notion page by setting the `in_trash` and `archived` properties to `$false`.
    This function uses the Notion API to perform the restore operation and returns the restored page object.

    .PARAMETER PageId
    The unique identifier of the Notion page to be restored. This parameter is mandatory.

    .OUTPUTS
    [notion_page]
    Returns a `notion_page` object representing the restored Notion page.

    .NOTES
    - The function supports `ShouldProcess` for confirmation and safety.
    - Use this function cautiously, as it interacts with the Notion API to modify page properties.

    .EXAMPLE
    Restore-NotionPage -PageId "12345abcde"

    Restores the Notion page with the ID `12345abcde` by removing it from the trash.

    .EXAMPLE
    Restore-NotionPage -PageId "67890fghij" -WhatIf

    Simulates the restore operation for the Notion page with the ID `67890fghij` without making any changes.

    .EXAMPLE
    Restore-NotionPage -PageId "67890fghij" -Confirm:$false

    Restores the Notion page with the ID `67890fghij` without prompting for confirmation.

    .LINK
    https://developers.notion.com/reference/patch-page
    https://developers.notion.com/reference/archive-a-page#example-request-restore-a-notion-page

    #>
    
    [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'High')]
    param(
        [Parameter(Mandatory = $true, Position=0, HelpMessage = "The ID of the page to remove")]
        [Alias("Id")]
        [string]$PageId
    )

    $body = @{
        in_trash = $false
        archived = $false
    }
    $body = $body | Remove-NullValuesFromObject
    if ($PSCmdlet.ShouldProcess($PageId))
    {
        $response = Invoke-NotionApiCall -method PATCH -uri "/pages/$PageId" -body $body
        return [notion_page]::ConvertFromObject($response)
    }
    else
    {
        return $null
    }
}
#EndRegion './Public/Page/Restore-NotionPage.ps1' 64
#Region './Public/User/Get-NotionUser.ps1' -1

function Get-NotionUser
{
    <#
    .SYNOPSIS
        Retrieves information about a specific Notion user.
    
    .DESCRIPTION
        The `Get-NotionUser` function retrieves details about a specific user from Notion by making a GET request
        to the Notion API's `/v1/users/{user_id}` endpoint, utilizing the `Invoke-NotionApiCall` function.
    
    .PARAMETER UserId
        The unique identifier of the Notion user. Possible values: '`$null' (list all users) or 'me' (the API User) or a user ID.
    
    .EXAMPLE
        $userId = "12345-67890-abcd-efgh"
        Get-NotionUser -UserId $userId
    
        This example retrieves information about the specified user from the Notion API.
    
    .NOTES
        - Ensure that the Notion API integration has the necessary permissions to access user information.
        - The API token and version are handled within the `Invoke-NotionApiCall` function.
    
    .LINK
        https://developers.notion.com/reference/get-user
    #>
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $false, HelpMessage = "Possible values: '`$null' or 'me' or a user ID.")]
        [Alias("Id")]
        [ValidatePattern("^(me|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})?$")]
        [string]$UserId
    )

    # Construct the API endpoint URL
    $url = "/users/$UserId"

    try
    {
        # Make the API call using the Invoke-NotionApiCall function
        $response = Invoke-NotionApiCall -uri $url -method "GET"

        # Return the response to the caller
        return $response.foreach({[notion_user]::ConvertFromObject($_)})
    }
    catch
    {
        # Handle any errors that occur during the API call
        Write-Error "Failed to retrieve the user information: $_"
    }
}
#EndRegion './Public/User/Get-NotionUser.ps1' 52
#Region './Public/zz1_Type_Accelerator.ps1' -1

# Define the types to export with type accelerators.
$ExportableTypes = @(
    # enums
    [rich_text_type]
    [notion_blocktype]
    [notion_database_property_type]
    #[relation_type]
    [notion_database_property_format_type]
    [notion_filetype]
    [notion_page_property_type]
    [notion_property_color]
    [notion_formula_type]
    [notion_rollup_type]
    [notion_rollup_function_type]
    [notion_page_verification_state]
    [notion_parent_type]
    [bot_owner_type]
    [notion_color]
    [icontype]
    [rich_text_mention_type]
    
    [template_mention_date]
    
    # classes
    [annotation]
    [heading_1]
    [heading_2]
    [heading_3]
    
    [notion_block]
    [notion_bookmark_block]
    [notion_bot_user]
    [notion_breadcrumb_block]
    [notion_bulleted_list_item_block]
    [notion_callout_block]
    [notion_checkbox_page_property]
    [notion_child_database_block]
    [notion_child_page_block]
    [notion_code_block]
    [notion_column_block]
    [notion_column_list_block]
    [notion_comment]
    [notion_created_by_page_property]
    [notion_created_time_page_property]
    [notion_custom_emoji]
    [notion_database]
    [notion_databaseproperties]
    [notion_date_page_property]
    [notion_divider_block]
    [notion_email_page_property]
    [notion_embed_block]
    [notion_emoji]
    [notion_equation_block]
    [notion_external_file]
    [notion_file]
    [notion_file_block]
    [notion_files_page_property]
    [notion_formula_page_property]
    [notion_hosted_file]
    [notion_image_block]
    [notion_last_edited_by_page_property]
    [notion_last_edited_time_page_property]
    [notion_link_preview_block]
    [notion_multi_select_item]
    [notion_multi_select_page_property]
    [notion_number_page_property]
    [notion_numbered_list_item_block]
    [notion_page]
    [notion_icon]
    [notion_page_parent]
    [notion_pageproperties]
    [notion_paragraph_block]
    [notion_parent]
    [notion_page_parent]
    [notion_workspace_parent]
    [notion_PDF_block]
    [notion_people_page_property]
    [notion_people_user]
    [notion_phone_number_page_property]
    [notion_quote_block]
    [notion_relation_page_property]
    [notion_rich_text_page_property]
    [notion_rollup_page_property]
    [notion_section_unfurl_attribute]
    [notion_select_page_property]
    [notion_status_page_property]
    [notion_sub_type_child_unfurl_attribute]
    [notion_sub_type_unfurl_attribute]
    [notion_synced_block]
    [notion_table_of_contents_block]
    [notion_title_page_property]
    [notion_to_do_block]
    [notion_toggle_block]
    [notion_unique_id_page_property]
    [notion_url_page_property]
    [notion_user]
    [notion_verification_page_property]
    [notion_video_block]

    #rich text
    [rich_text]
    [rich_text_equation]
    [rich_text_equation_structure]
    [rich_text_mention]
    [rich_text_mention_base]
    [rich_text_mention_database]
    [rich_text_mention_database_structure]
    [rich_text_mention_date]
    [rich_text_mention_date_structure]
    [rich_text_mention_link_preview]
    [rich_text_mention_page]
    [rich_text_mention_page_structure]
    [rich_text_mention_template_mention]
    [rich_text_mention_template_mention_structure_base]
    [rich_text_mention_template_mention_template_mention_date_structure]
    [rich_text_mention_template_mention_template_mention_user_structure]
    [rich_text_mention_user]
    [rich_text_text]
    [rich_text_text_structure]

    # TODO: remove before release
    [PagePropertiesBase]
)
#EndRegion './Public/zz1_Type_Accelerator.ps1' 124
#Region './Public/zz2_Type_Accelerator.ps1' -1

# Get the internal TypeAccelerators class to use its static methods.
$TypeAcceleratorsClass = [psobject].Assembly.GetType(
    'System.Management.Automation.TypeAccelerators'
)
# Ensure none of the types would clobber an existing type accelerator.
# If a type accelerator with the same name exists, throw an exception.
$ExistingTypeAccelerators = $TypeAcceleratorsClass::Get
foreach ($Type in $ExportableTypes)
{
    if ($Type.FullName -in $ExistingTypeAccelerators.Keys)
    {
        $Message = @(
            "Unable to register type accelerator '$($Type.FullName)'"
            'Accelerator already exists.'
        ) -join ' - '

        throw [System.Management.Automation.ErrorRecord]::new(
            [System.InvalidOperationException]::new($Message),
            'TypeAcceleratorAlreadyExists',
            [System.Management.Automation.ErrorCategory]::InvalidOperation,
            $Type.FullName
        )
    }
}
# Add type accelerators for every exportable type.
foreach ($Type in $ExportableTypes)
{
    $TypeAcceleratorsClass::Add($Type.FullName, $Type)
}
# Remove type accelerators when the module is removed.
$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = {
    foreach ($Type in $ExportableTypes)
    {
        $TypeAcceleratorsClass::Remove($Type.FullName)
    }
}.GetNewClosure()
#EndRegion './Public/zz2_Type_Accelerator.ps1' 37