PSImmich

1.118.0-preview0001

PSImmich.psm1

#Region './prefix.ps1' -1

# The content of this file will be prepended to the top of the psm1 module file. This is useful for custom module setup is needed on import.

Update-FormatData -AppendPath "$PSScriptRoot\Format\PSImmich.Format.ps1xml"
#EndRegion './prefix.ps1' 4
#Region './Classes/ImmichSession.class.ps1' -1

[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSAvoidUsingConvertToSecureStringWithPlainText', '', Justification = 'JWT token retreived in plain text')]
class ImmichSession
{
    [string]$BaseUri
    [string]$AuthMethod
    [securestring]$AccessToken
    [boolean]$AccessTokenValid
    [pscredential]$Credential
    [securestring]$JWT
    [string]$APIUri
    [string]$ImmichVersion
    [string]$SessionID

    ImmichSession ([string]$BaseUri, [securestring]$AccessToken)
    {
        Write-Debug -Message 'ImmichSession.Class; Running constructor accesstoken'
        $this.SessionID = (New-Guid).Guid
        $this.BaseUri = $BaseUri
        $this.APIUri = "$BaseUri/api"
        $this.AuthMethod = 'AccessToken'
        $this.AccessToken = $AccessToken
        $this.GetStatus()
        Write-Verbose -Message "Connected to Immich instance at $($this.BaseUri) with AccessToken"
    }

    ImmichSession ([string]$BaseUri, [pscredential]$Credential)
    {
        Write-Debug -Message 'ImmichSession.Class; Running constructor credential'
        $this.SessionID = (New-Guid).Guid
        $this.BaseUri = $BaseUri
        $this.APIUri = "$BaseUri/api"
        $this.AuthMethod = 'Credential'
        $this.Credential = $Credential
        $this.AuthenticateCredential()
        $this.GetStatus()
        Write-Verbose -Message "Connected to Immich instance at $($this.BaseUri) with Credentials"
    }

    ValidateToken()
    {
        try
        {
            if ($this.AuthMethod -eq 'Credential')
            {
                $Result = Invoke-RestMethod -Method Post -Uri "$($this.ApiUri)/auth/validateToken" -Headers @{Authorization = "Bearer $(ConvertFromSecureString -SecureString $this.JWT)" } | Select-Object -Property AuthStatus
            }
            else
            {
                $Result = Invoke-RestMethod -Method Post -Uri "$($this.ApiUri)/auth/validateToken" -Headers @{'X-API-Key' = "$(ConvertFromSecureString -SecureString $this.AccessToken)" } | Select-Object -Property AuthStatus
            }
        }
        catch
        {
            $this.AccessTokenValid = $false
            throw $_.Exception.message
        }
        if ($Result)
        {
            $this.AccessTokenValid = $true
        }
        else
        {
            $this.AccessTokenValid = $false
            throw 'AccessToken is not valid, please reconnect'
        }
    }

    hidden AuthenticateCredential()
    {
        $BodyObject = @{
            password = $this.Credential.GetNetworkCredential().Password
            email    = $this.Credential.Username
        }
        $JWTResponse = InvokeImmichRestMethod -NoAuth -Method:'Post' -ImmichSession $this -RelativePath '/auth/login' -Body $BodyObject
        $this.JWT = ConvertTo-SecureString -String $JWTResponse.accessToken -AsPlainText -Force
        $this.AccessToken = ConvertTo-SecureString -String $JWTResponse.accessToken -AsPlainText -Force
        Remove-Variable -Name JWTResponse
    }

    hidden GetStatus()
    {
        $this.ValidateToken()
        $Status = InvokeImmichRestMethod -Method:'Get' -ImmichSession $this -RelativePath '/server/version'
        $this.ImmichVersion = "$($Status.Major).$($Status.Minor).$($Status.Patch)"
        Remove-Variable -Name Status
    }

}
#EndRegion './Classes/ImmichSession.class.ps1' 89
#Region './Private/AddCustomType.ps1' -1

function AddCustomType
{
    <#
    .DESCRIPTION
        Helper function to tag a type name to objects, this is used for formatting.
    .PARAMETER InputObject
        Defines the input object
    .PARAMETER Type
        Defines the type name to tag each passed object with
    .EXAMPLE
        $Objects | AddCustomType -Type IMAsset
    #>
    param(
        [Parameter(Mandatory, ValueFromPipeline)]
        [object]
        $InputObject,

        [Parameter(Mandatory, Position = 1)]
        [string]
        $Type
    )

    BEGIN
    {
        $TypeName = "PSImmich.ObjectType.$Type"
    }

    PROCESS
    {
        $InputObject | ForEach-Object {
            if ($PSItem.PSObject.TypeNames -notcontains $TypeName)
            {
                $null = $PSItem.Psobject.TypeNames.Insert(0, $TypeName)
            }
            $PSItem
        }
    }
}
#EndRegion './Private/AddCustomType.ps1' 39
#Region './Private/ConvertFromSecureString.ps1' -1

function ConvertFromSecureString
{
    <#
    .DESCRIPTION
        Function that retreives the original value of the securestring. Obsolete in Windows Core becuase
        ConvertFrom-SecureString has an AsPlainText parameter but this function is instead used for
        Windows Powershell backwards compatiblity.
    .PARAMETER SecureString
        Defines the input securestring variable.
    .EXAMPLE
        ConvertFromSecureString
    #>
    param(
        [securestring]$SecureString
    )

    # Windows Powershell does not include ConvertFrom-SecureString -AsPlainText parameter.
    if ($PSVersionTable.PSEdition -eq 'Desktop')
    {
        $BSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($SecureString)
        $UnsecurePassword = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)
        [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($BSTR)
    }
    # Due to text encoding differences between windows and linux PtrToStringAuto does not work as expected with BSTR
    elseif ($PSVersionTable.PSEdition -eq 'Core')
    {
        $UnsecurePassword = ConvertFrom-SecureString -SecureString $SecureString -AsPlainText
    }

    return ($UnsecurePassword -join '')
}
#EndRegion './Private/ConvertFromSecureString.ps1' 32
#Region './Private/InvokeImmichRestMethod.ps1' -1

function InvokeImmichRestMethod
{
    <#
    .DESCRIPTION
        Function that is responsible for making the rest api web call
    .PARAMETER NoAuth
        Specifies that the REST API call do not need authentication
    .PARAMETER Method
        Defines the method to use when calling the REST API, valid values GET,POST etc.
    .PARAMETER ImmichSession
        A ImmichSession object to use for the call.
    .PARAMETER RelativePath
        The REST API path relative to the base URL
    .PARAMETER Body
        Defines body attributes for the REST API call
    .PARAMETER Headers
        Defines header attributes for the REST API call
    .PARAMETER QueryParameters
         Defines QueryParameters for the REST API call
    .PARAMETER ContentType
        Defines the contenttype for the request
    .PARAMETER OutFilePath
        Defines an output directory
    .PARAMETER RawBody
        Provides a raw body to use instead of parsing a hashtable to json.
    .EXAMPLE
        InvokeImmichRestMethod
    #>
    [CmdletBinding()] # Enabled advanced function support
    param(
        [switch]$NoAuth,
        [string]$Method,
        [immichsession]$ImmichSession,
        [string]$RelativePath,
        [hashtable]$Body,
        [string]$RawBody,
        [hashtable]$Headers,
        [hashtable]$QueryParameters,
        [string]$ContentType = 'application/json',
        [System.IO.FileInfo]$OutFilePath
    )

    # Use immich session from parameter first, from module scope session second and throw if none is found
    if (-not $ImmichSession)
    {
        Write-Debug -Message 'InvokeImmichRestMethod; No ImmichSession passed as parameter'
        if ($script:ImmichSession)
        {
            Write-Debug -Message 'InvokeImmichRestMethod; ImmichSession found in script scope'
            $ImmichSession = $script:ImmichSession
        }
        else
        {
            Write-Error -Message 'No Immich Session established, please call Connect-Immich' -ErrorAction Stop
        }
    }

    # Initialize invoke rest method splat
    $InvokeRestMethodSplat = @{
        Method      = $Method
        Uri         = "$($ImmichSession.ApiUri)$($RelativePath)"
        ContentType = $ContentType
    }

    # Skip auth headers if noauth is specified
    if (-not $NoAuth)
    {
        # Custom headers has not been provided so we need to initialize an empty hashtable
        if (-not $Headers)
        {
            $Headers = @{}
        }
        switch ($ImmichSession.AuthMethod)
        {
            'Credential'
            {
                $Headers.Authorization = "Bearer $(ConvertFromSecureString -SecureString $ImmichSession.JWT)"
            }
            'AccessToken'
            {
                $Headers.'X-API-Key' = ConvertFromSecureString -SecureString $ImmichSession.AccessToken
            }
        }
    }

    # Add headers to invoke rest method splat
    if ($Headers)
    {
        $InvokeRestMethodSplat.Headers = $Headers
    }

    # Add body to invoke rest method splat
    if ($Body)
    {
        $NewBody = @{}
        foreach ($Key in $Body.Keys)
        {
            switch ($Body.$Key.GetType().Name)
            {
                'boolean'
                {
                    $NewBody.$Key = $Body.$Key.ToString().ToLower()
                    break
                }
                'SwitchParameter'
                {
                    $NewBody.$Key = ($Body.$Key -as [boolean]).ToString().ToLower()
                    break
                }
                'datetime'
                {
                    $NewBody.$Key = $Body.$Key.ToString('yyyy-MM-ddTHH:mm:ss')
                    break
                }
                'SecureString'
                {
                    $NewBody.$Key = ConvertFromSecureString -SecureString $Body.$Key
                }
                default
                {
                    $NewBody.$Key = $Body.$Key
                }
            }
        }
        $InvokeRestMethodSplat.Body = $NewBody | ConvertTo-Json -Compress
    }

    if ($RawBody)
    {
        $InvokeRestMethodSplat.Body = $RawBody
    }

    # Add query parameters to invoke rest method splat
    if ($QueryParameters)
    {
        $InvokeRestMethodSplat.Uri += '?'
        $QueryParameterStringArray = foreach ($QueryParameter in $QueryParameters.Keys)
        {
            switch ($QueryParameters.$QueryParameter.GetType().Name)
            {
                'string'
                {
                    "$($QueryParameter)=$($QueryParameters.$QueryParameter)"
                }
                'boolean'
                {
                    "$($QueryParameter)=$($QueryParameters.$QueryParameter.ToString().ToLower())"
                }
                'SwitchParameter'
                {
                    "$($QueryParameter)=$(($QueryParameters.$QueryParameter -as [boolean]).ToString().ToLower())"
                }
                'int32'
                {
                    "$($QueryParameter)=$($QueryParameters.$QueryParameter)"
                }
                'double'
                {
                    "$($QueryParameter)=$($QueryParameters.$QueryParameter)"
                }
                'datetime'
                {
                    "$($QueryParameter)=$($QueryParameters.$QueryParameter.ToString('yyyy-MM-ddTHH:mm:ss'))"
                }
                default
                {
                    Write-Warning -Message "Unknown type of queryparameter $QueryParameter : $($QueryParameters.$QueryParameter.GetType().Name)"
                }
            }
        }
        $InvokeRestMethodSplat.Uri += [URI]::EscapeUriString(($QueryParameterStringArray -join '&'))
    }

    # Skip token validation on auth/login calls because the token is not retreived at that point
    if ($InvokeRestMethodSplat.Uri -notlike '*auth/login*')
    {
        $ImmichSession.ValidateToken()
    }

    Write-Debug -Message "InvokeImmichRestMethod; Calling Invoke-RestMethod with settings`r`n$($InvokeRestMethodSplat | ConvertTo-Json)"

    # Output response to file if content type is octet-stream
    if ($ContentType -eq 'application/octet-stream' -and $Method -eq 'Get')
    {
        Invoke-RestMethod @InvokeRestMethodSplat -Verbose:$false -OutFile $OutFilePath
    }
    else
    {
        Invoke-RestMethod @InvokeRestMethodSplat -Verbose:$false | ForEach-Object { if ($_ -ne '' -and $null -ne $_)
            {
                $_
            } }
    }

}


#endregion
#EndRegion './Private/InvokeImmichRestMethod.ps1' 199
#Region './Private/SelectBinding.ps1' -1

function SelectBinding
{
    <#
    .DESCRIPTION
        Function that is extracts what parameters the cmdlet was called with
    .PARAMETER Binding
        PSBoundParameters object should be passed
    .PARAMETER SelectProperty
        String array of the properties that should be extracted.
    .PARAMETER NameMapping
        Defines a hashtable where a parametername can be mapped to different name of the API parameter name.
    .EXAMPLE
        SelectBinding
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    param(
        $Binding,
        [string[]]$SelectProperty,
        [hashtable]$NameMapping
    )

    $ReturnHash = @{}

    # Only process binded parameters that we are intreseted in
    foreach ($Parameter in ($Binding.Keys | Where-Object { $SelectProperty -contains $PSItem }))
    {
        if ($NameMapping.Keys -contains $Parameter)
        {
            $APIName = $NameMapping[$Parameter]
        }
        else
        {
            $APIName = $Parameter
        }

        $ReturnHash.Add($APIName, $Binding[$Parameter])
    }
    return $ReturnHash

}
#EndRegion './Private/SelectBinding.ps1' 41
#Region './Public/Activity/Add-IMActivity.ps1' -1

function Add-IMActivity
{
    <#
    .DESCRIPTION
        Adds a new activity to an album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines which album to add the activity to.
    .PARAMETER assetId
        Defines a specific assetid to add activities for.
    .PARAMETER comment
        Defines the comment to add.
    .PARAMETER type
        Defines the type of activity to add, valid values are comment or like.
    .EXAMPLE
        Add-IMActivity -AlbumId <albumid> -AssetId <assetid> -Comment 'Great picture!' -Type comment

        Adds a new comment to an asset in the specified album
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $assetId,

        [Parameter()]
        [string]
        $comment,

        [Parameter()]
        [ValidateSet('comment', 'like')]
        [string]
        $type
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'albumId', 'assetId', 'comment', 'type')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Post -RelativePath '/activities' -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/Activity/Add-IMActivity.ps1' 63
#Region './Public/Activity/Get-IMActivity.ps1' -1

function Get-IMActivity
{
    <#
    .DESCRIPTION
        Retreives album activity
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines the album to retreive activities for.
    .PARAMETER assetId
        Defines a asset to retreive activities for.
    .PARAMETER level
        Defines the level of activities to retreive, valid values are album or asset.
    .PARAMETER type
        Defines the type of activities to retreive, valid values are comment or like.
    .PARAMETER userId
        Defines a specific user to retreive activities for.
    .EXAMPLE
        Get-IMActivity -albumId 'bde7ceba-f301-4e9e-87a2-163937a2a3db'

        Retreives all activities for an album
    .EXAMPLE
        Get-IMActivity -albumId 'bde7ceba-f301-4e9e-87a2-163937a2a3db' -assetId 'a4908e1f-697f-4d7b-9330-93b5eabe3baf'

        Retreives all activities for an album and a specific asset
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $assetId,

        [Parameter()]
        [ValidateSet('album', 'asset')]
        [string]
        $level,

        [Parameter()]
        [ValidateSet('comment', 'like')]
        [string]
        $type,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $userId
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'albumId', 'assetId', 'level', 'type', 'userId')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Get -RelativePath '/activities' -ImmichSession:$Session -QueryParameters $QueryParameters | AddCustomType IMActivity
    }

}
#endregion
#EndRegion './Public/Activity/Get-IMActivity.ps1' 75
#Region './Public/Activity/Get-IMActivityStatistic.ps1' -1

function Get-IMActivityStatistic
{
    <#
    .DESCRIPTION
        Retreives album activity
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines an album to retreive activity statistics for.
    .PARAMETER assetId
        Defines a specific asset to retreive activities for.
    .EXAMPLE
        Get-IMActivityStatistic -albumId 'bde7ceba-f301-4e9e-87a2-163937a2a3db'

        Retreives activity statistics for the album
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $assetId
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'albumId', 'assetId')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Get -RelativePath '/activities/statistics' -ImmichSession:$Session -QueryParameters $QueryParameters
    }

}
#endregion
#EndRegion './Public/Activity/Get-IMActivityStatistic.ps1' 50
#Region './Public/Activity/Remove-IMActivity.ps1' -1

function Remove-IMActivity
{
    <#
    .DESCRIPTION
        Removes an activity
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Id
        Defines the activity to remove
    .EXAMPLE
        Remove-IMActivity -id 'bde7ceba-f301-4e9e-87a2-163937a2a3db'

        Removes the activity
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id
    )

    PROCESS
    {
        if ($PSCmdlet.ShouldProcess($id, 'DELETE'))
        {
            InvokeImmichRestMethod -Method DELETE -RelativePath "/activities/$id" -ImmichSession:$Session
        }
    }

}
#endregion
#EndRegion './Public/Activity/Remove-IMActivity.ps1' 40
#Region './Public/Album/Add-IMAlbumUser.ps1' -1

function Add-IMAlbumUser
{
    <#
    .DESCRIPTION
        Add user to album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines album to add the user to
    .PARAMETER userId
        Defines the user to add to the album
    .PARAMETER role
        Defines the user role
    .EXAMPLE
        Add-IMAlbumUser -albumid <albumid> -userid <userid> -role editor

        Add user to album
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter(Mandatory, ValueFromPipeline, ValueFromPipelineByPropertyName)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('id')]
        [string[]]
        $userId,

        [Parameter()]
        [ValidateSet('editor','viewer')]
        [string]
        $Role = 'viewer'
    )

    BEGIN
    {
        $BodyParameters = @{
            albumUsers = [object[]]@()
        }
    }

    PROCESS
    {
        $userId | ForEach-Object {
            $UserObject = [pscustomobject]@{
                userId = $PSItem
                role = $Role
            }
            $BodyParameters.albumUsers += $UserObject
        }
    }

    END
    {
        InvokeImmichRestMethod -Method PUT -RelativePath "/albums/$albumid/users" -ImmichSession:$Session -Body:$BodyParameters
    }
}
#endregion
#EndRegion './Public/Album/Add-IMAlbumUser.ps1' 69
#Region './Public/Album/Get-IMAlbum.ps1' -1

function Get-IMAlbum
{
    <#
    .DESCRIPTION
        Retreives Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER AlbumId
        Defines the album to get
    .PARAMETER AssetId
        Only returns albums that contain the asset
    .PARAMETER Shared
        Defines weather to return shared albums or not.
    .PARAMETER IncludeAssets
        Defines weather to return assets as part of the object or not
    .PARAMETER Name
        Specify an exact name of an album
    .PARAMETER SearchString
        Specify a string to search for in album names, accepts wildcard
    .EXAMPLE
        Get-IMAlbum -albumid <albumid>

        Retreives Immich album
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('Id')]
        [string]
        $AlbumId,

        [Parameter(ParameterSetName = 'list')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $AssetId,

        [Parameter(ParameterSetName = 'id')]
        [Parameter(ParameterSetName = 'list')]
        [switch]
        $IncludeAssets,

        [Parameter(ParameterSetName = 'list')]
        [boolean]
        $Shared,

        [Parameter(ParameterSetName = 'list')]
        [string]
        $Name,

        [Parameter(ParameterSetName = 'list')]
        [string]
        $SearchString
    )

    BEGIN
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'list'
            {
                $QueryParameters = @{}
                $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Shared' -NameMapping @{'Shared' = 'shared' })
                $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'AssetId' -NameMapping @{'AssetId' = 'assetId' })
            }
            'id'
            {
                $QueryParameters = @{}
                $QueryParameters.withoutAssets = (-not $IncludeAssets)
            }
        }
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'list'
            {
                $Result = InvokeImmichRestMethod -Method Get -RelativePath '/albums' -ImmichSession:$Session -QueryParameters $QueryParameters
                if ($Name)
                {
                    $Result = $Result | Where-Object { $_.AlbumName -eq $Name }
                }
                if ($SearchString)
                {
                    $Result = $Result | Where-Object { $_.Albumname -like $SearchString }
                }
                if (-not $IncludeAssets)
                {
                    $Result | AddCustomType IMAlbum
                }
                else
                {
                    $Result | ForEach-Object {
                        Get-IMAlbum -Id $PSItem.Id -IncludeAssets
                    } | AddCustomType IMAlbum
                }

            }
            'id'
            {
                InvokeImmichRestMethod -Method Get -RelativePath "/albums/$albumId" -ImmichSession:$Session -QueryParameters $QueryParameters | AddCustomType IMAlbum
            }
        }
    }

}
#endregion
#EndRegion './Public/Album/Get-IMAlbum.ps1' 117
#Region './Public/Album/Get-IMAlbumStatistic.ps1' -1

function Get-IMAlbumStatistic
{
    <#
    .DESCRIPTION
        Retreives Immich album statistics
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMAlbumStatistics

        Retreives Immich album statistics
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/albums/statistics' -ImmichSession:$Session
}
#endregion
#EndRegion './Public/Album/Get-IMAlbumStatistic.ps1' 26
#Region './Public/Album/New-IMAlbum.ps1' -1

function New-IMAlbum
{
    <#
    .DESCRIPTION
        Adds a new album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumName
        Defines the name of the new album
    .PARAMETER assetIds
        Defines a list of assets to add to the album
    .PARAMETER description
        Defines a description for the album
    .PARAMETER albumUsers
        Defines a list of user id to share the album to
    .EXAMPLE
        New-IMAlbum -albumName 'Las Vegas'

        Adds a new an album
    .EXAMPLE
        New-IMAlbum -AlbumName 'Las Vegas' -AlbumUsers @{userId='<userid>';role='editor'}

        Adds a new shared album that is shared to a user
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Do not agree, new initiates an entity not previously known to the system, that should not cause issues.')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string]
        $albumName,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $assetIds,

        [Parameter()]
        [string]
        $description,

        [Parameter()]
        [hashtable[]]
        $albumUsers
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'albumName', 'assetIds', 'description', 'albumUsers')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Post -RelativePath '/albums' -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/Album/New-IMAlbum.ps1' 65
#Region './Public/Album/Remove-IMAlbum.ps1' -1

function Remove-IMAlbum
{
    <#
    .DESCRIPTION
        Removes an Immich album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines the album that should be removed. Accepts pipeline input.
    .EXAMPLE
        Remove-IMAlbum -albumid <albumid>

        Removes an album
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('id')]
        [string[]]
        $albumId
    )

    PROCESS
    {
        # We loop through IDs because ids can be provided as an array to the parameter in which case the process block only gets called once.
        $albumId | ForEach-Object {
            $CurrentID = $PSItem
            if ($PSCmdlet.ShouldProcess($CurrentID, 'DELETE'))
            {
                InvokeImmichRestMethod -Method Delete -RelativePath "/albums/$CurrentID" -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/Album/Remove-IMAlbum.ps1' 44
#Region './Public/Album/Remove-IMAlbumUser.ps1' -1

function Remove-IMAlbumUser
{
    <#
    .DESCRIPTION
        Remove user from album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines album to remove users from
    .PARAMETER userId
        Defines the user to remove from the album
    .EXAMPLE
        Remove-IMAlbumUser -albumid <albumid> -userid <userid>

        Remove user from album
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'albumId', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter(Mandatory, ValueFromPipeline, ValueFromPipelineByPropertyName)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('id')]
        [string[]]
        $userId
    )

    PROCESS
    {
        $userId | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'DELETE'))
            {
                InvokeImmichRestMethod -Method DELETE -RelativePath "/albums/$albumId/user/$psitem" -ImmichSession:$Session
            }
        }
    }

}
#endregion
#EndRegion './Public/Album/Remove-IMAlbumUser.ps1' 51
#Region './Public/Album/Rename-IMAlbum.ps1' -1

function Rename-IMAlbum
{
    <#
    .DESCRIPTION
        Renames an Immich album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines albums to update
    .PARAMETER NewName
        Defines a new album name
    .EXAMPLE
        Rename-IMAlbum -id <albumid> -NewName 'New York 2024'

        Renames the album
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('ids', 'albumId')]
        [string[]]
        $id,

        [Parameter(Mandatory)]
        [string]
        $NewName
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'NewName' -NameMapping @{
                NewName = 'albumName'
            })
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'Update'))
            {
                InvokeImmichRestMethod -Method PATCH -RelativePath "/albums/$PSItem" -ImmichSession:$Session -Body:$BodyParameters
            }
        }
    }
}
#endregion
#EndRegion './Public/Album/Rename-IMAlbum.ps1' 56
#Region './Public/Album/Set-IMAlbum.ps1' -1

function Set-IMAlbum
{
    <#
    .DESCRIPTION
        Updates an Immich album
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines albums to update
    .PARAMETER albumName
        Defines a new album name
    .PARAMETER albumThumbnailAssetId
        Defines a UUID for a new thumbnail asset
    .PARAMETER description
        Defines a new description for the album
    .PARAMETER isActivityEnabled
        Defines weather activity feed should be enabled
    .PARAMETER AddAssets
        Defines assets to add to the album
    .PARAMETER RemoveAssets
        Defines assets to be removed from the album
    .PARAMETER Order
        Defines the sort order for the album
    .EXAMPLE
        Set-IMAlbum -id <albumid> -description 'Trip to New York'

        Update the description of an Immich album
    .EXAMPLE
        Set-IMAlbum -id <albumid> -AddAssets <assetid>,<assetid>

        Adds to assets to the album
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('ids', 'albumId')]
        [string[]]
        $id,

        [Parameter()]
        [string[]]
        $AddAssets,

        [Parameter()]
        [string[]]
        $RemoveAssets,

        [Parameter()]
        [string]
        $albumName,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumThumbnailAssetId,

        [Parameter()]
        [string]
        $description,

        [Parameter()]
        [boolean]
        $isActivityEnabled,

        [Parameter()]
        [string]
        [ValidateSet('asc', 'desc')]
        $Order
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'AlbumName', 'albumThumbnailAssetId', 'description', 'isActivityEnabled', 'Order' -namemapping @{AlbumName = 'albumName'; albumThumbnailAssetId = 'albumThumbnailAssetId'; isActivityEnabled = 'isActivityEnabled'; Order = 'order' })
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'Update'))
            {
                InvokeImmichRestMethod -Method PATCH -RelativePath "/albums/$PSItem" -ImmichSession:$Session -Body:$BodyParameters

                if ($PSBoundParameters.ContainsKey('AddAssets'))
                {
                    $null = InvokeImmichRestMethod -Method PUT -RelativePath "/albums/$PSItem/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$AddAssets }
                }
                if ($PSBoundParameters.ContainsKey('RemoveAssets'))
                {
                    $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/albums/$PSItem/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$RemoveAssets }
                }
            }
        }
    }
}
#endregion
#EndRegion './Public/Album/Set-IMAlbum.ps1' 105
#Region './Public/Album/Set-IMAlbumUser.ps1' -1

function Set-IMAlbumUser
{
    <#
    .DESCRIPTION
        Set user role
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Defines album to add the user to
    .PARAMETER userId
        Defines the user to add to the album
    .PARAMETER role
        Defines the user role
    .EXAMPLE
        Set-IMAlbumUser -albumid <albumid> -userid <userid> -role editor

        Changes the role of the user in the specified album
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter(Mandatory, ValueFromPipeline, ValueFromPipelineByPropertyName)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('id')]
        [string[]]
        $userId,

        [Parameter(Mandatory)]
        [ValidateSet('editor','viewer')]
        [string]
        $Role
    )

    BEGIN
    {
        $BodyParameters = @{
            role = $Role
        }
    }

    PROCESS
    {
        $userId | ForEach-Object {
            InvokeImmichRestMethod -Method PUT -RelativePath "/albums/$albumid/user/$PSItem" -ImmichSession:$Session -Body:$BodyParameters
        }
    }
}
#endregion
#EndRegion './Public/Album/Set-IMAlbumUser.ps1' 60
#Region './Public/APIKey/Get-IMAPIKey.ps1' -1

function Get-IMAPIKey
{
    <#
    .DESCRIPTION
        Retreives api keys
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines an api key id to get
    .EXAMPLE
        Get-IMAPIKey

        Retreives all api keys
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            switch ($PSCmdlet.ParameterSetName)
            {
                'list'
                {
                    InvokeImmichRestMethod -Method Get -RelativePath '/api-keys' -ImmichSession:$Session | AddCustomType IMAPIKey
                }
                'id'
                {
                    InvokeImmichRestMethod -Method Get -RelativePath "/api-keys/$CurrentID" -ImmichSession:$Session | AddCustomType IMAPIKey
                }
            }
        }
    }

}
#endregion
#EndRegion './Public/APIKey/Get-IMAPIKey.ps1' 50
#Region './Public/APIKey/New-IMAPIKey.ps1' -1

function New-IMAPIKey
{
    <#
    .DESCRIPTION
        Adds a new an api key
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER name
        Defines the name of the new api key
    .PARAMETER permission
        Defines the permissions for the API-key
    .EXAMPLE
        New-IMAPIKey -name 'Automation'

        Adds a new an api key
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Do not agree, new initiates an entity not previously known to the system, that should not cause issues.')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string]
        $name,

        [Parameter()]
        [ValidateSet("all", "activity.create", "activity.read", "activity.update", "activity.delete", "activity.statistics", "apiKey.create", "apiKey.read", "apiKey.update", "apiKey.delete", "asset.read", "asset.update", "asset.delete", "asset.share", "asset.view", "asset.download", "asset.upload", "album.create", "album.read", "album.update", "album.delete", "album.statistics", "album.addAsset", "album.removeAsset", "album.share", "album.download", "authDevice.delete", "archive.read", "face.create", "face.read", "face.update", "face.delete", "library.create", "library.read", "library.update", "library.delete", "library.statistics", "timeline.read", "timeline.download", "memory.create", "memory.read", "memory.update", "memory.delete", "partner.create", "partner.read", "partner.update", "partner.delete", "person.create", "person.read", "person.update", "person.delete", "person.statistics", "person.merge", "person.reassign", "session.read", "session.update", "session.delete", "sharedLink.create", "sharedLink.read", "sharedLink.update", "sharedLink.delete", "stack.create", "stack.read", "stack.update", "stack.delete", "systemConfig.read", "systemConfig.update", "systemMetadata.read", "systemMetadata.update", "tag.create", "tag.read", "tag.update", "tag.delete", "tag.asset", "admin.user.create", "admin.user.read", "admin.user.update", "admin.user.delete")]
        [string[]]
        $Permission = 'all'
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'name','permission' -NameMapping @{name = 'name'; Permission = 'permissions'})
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method POST -RelativePath '/api-keys' -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/APIKey/New-IMAPIKey.ps1' 49
#Region './Public/APIKey/Remove-IMAPIKey.ps1' -1

function Remove-IMAPIKey
{
    <#
    .DESCRIPTION
        Removes Immich api key
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines an api key to remove
    .EXAMPLE
        Remove-IMAPIKey -id <apikey id>

        Remove api key
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            if ($PSCmdlet.ShouldProcess($CurrentID, 'DELETE'))
            {
                InvokeImmichRestMethod -Method DELETE -RelativePath "/api-keys/$CurrentID" -ImmichSession:$Session
            }
        }
    }

}
#endregion
#EndRegion './Public/APIKey/Remove-IMAPIKey.ps1' 43
#Region './Public/APIKey/Rename-IMAPIKey.ps1' -1

function Rename-IMAPIKey
{
    <#
    .DESCRIPTION
        Sets name of an apikey
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the id of the API key to update
    .PARAMETER name
        Defines a new name for the apikey
    .EXAMPLE
        Rename-IMAPIKey

        Sets name of an apikey
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Do not agree, new initiates an entity not previously known to the system, that should not cause issues.')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter(Mandatory)]
        [string]
        $name

    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'name')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method PUT -RelativePath "/api-keys/$id" -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/APIKey/Rename-IMAPIKey.ps1' 50
#Region './Public/Asset/Export-IMAssetThumbnail.ps1' -1

function Export-IMAssetThumbnail
{
    <#
    .DESCRIPTION
        Retreives the asset thumbnail
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Id
        Defines the asset ID to query
    .PARAMETER Path
        Defines the directory for the output file
    .EXAMPLE
        Get-IMAssetThumbnail

        Retreives asset thumbnails
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter()]
        [System.IO.DirectoryInfo]
        $Path
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            $OutputPath = Join-Path -Path $Path -ChildPath "$($CurrentID).jpeg"
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $SavedProgressPreference = $global:ProgressPreference
                $global:ProgressPreference = 'SilentlyContinue'
            }
            InvokeImmichRestMethod -Method Get -RelativePath "/assets/$id/thumbnail" -ImmichSession:$Session -ContentType 'application/octet-stream' -OutFilePath $OutputPath
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $global:ProgressPreference = $SavedProgressPreference
            }
        }
    }

}
#endregion
#EndRegion './Public/Asset/Export-IMAssetThumbnail.ps1' 56
#Region './Public/Asset/Get-IMAsset.ps1' -1

function Get-IMAsset
{
    <#
    .DESCRIPTION
        Retreives Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific asset id to be retreived
    .PARAMETER isFavorite
        Defines if faviorites should be returned or not. Do not specify if either should be returned.
    .PARAMETER isArchived
        Defines if archvied assets should be returned or not. Do not specify if either should be returned.
    .PARAMETER skip
        Defines skip
    .PARAMETER take
        Defines take
    .PARAMETER updatedAfter
        Deinfes updatedAfter
    .PARAMETER updatedBefore
        Defines updatedBefore
    .PARAMETER userId
        Defines userId
    .PARAMETER deviceId
        Defines a device id
    .PARAMETER personId
        Defines a personId to retreive assets for
    .PARAMETER tagId
        Defines a tagid to retreive assets for
    .PARAMETER Random
        Defines that random assets should be retreived. Unless -count is also specified one random asset is returned.
    .PARAMETER Count
        Defines how many random assets should be returned. Required -Random
    .EXAMPLE
        Get-IMAsset -isFavorite:$true

        Retreives all favorites
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'random')]
        [switch]
        $Random,

        [Parameter(ParameterSetName = 'random')]
        [ValidateRange(1,1000)]
        [int]
        $Count = 1,

        [Parameter(Mandatory, ParameterSetName = 'deviceid')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $deviceID,

        [Parameter(Mandatory, ParameterSetName = 'personid')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $personId,

        [Parameter(Mandatory, ParameterSetName = 'tagid')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $tagId,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id
    )

    BEGIN
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'id'
            {
                $QueryParameters = @{}
                $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'isFavorite', 'isArchived', 'skip', 'take', 'updatedAfter', 'updatedBefore', 'userId', 'key')
            }
        }
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'id'
            {
                InvokeImmichRestMethod -Method Get -RelativePath "/assets/$id" -ImmichSession:$Session -QueryParameters $QueryParameters | AddCustomType IMAsset
            }
            'deviceid'
            {
                InvokeImmichRestMethod -Method Get -RelativePath "/assets/device/$deviceid" -ImmichSession:$Session | Get-IMAsset
            }
            'personId'
            {
                InvokeImmichRestMethod -Method Get -RelativePath "/people/$personid/assets" -ImmichSession:$Session | Get-IMAsset
            }
            'tagid'
            {
                InvokeImmichRestMethod -Method Get -RelativePath "/tags/$tagid/assets" -ImmichSession:$Session | Get-IMAsset
            }
            'random'
            {
                # Requires body, but we wont provide any parameters in this case. TBD
                $Body = @{
                    size = $Count
                }
                InvokeImmichRestMethod -Method POST -RelativePath '/search/random' -ImmichSession:$Session -Body:$Body | AddCustomType IMAsset
            }
            'list'
            {
                Find-IMAsset
                Write-Warning -Message 'Previous versions of Immich allowed enumeration of all assets using the Assets endpoint. This is deprecated and Find- should now be used. To enumerate all assets you can call Find-IMAsset.'
            }
        }
    }
}
#endregion
#EndRegion './Public/Asset/Get-IMAsset.ps1' 127
#Region './Public/Asset/Get-IMAssetMemoryLane.ps1' -1

function Get-IMAssetMemoryLane
{
    <#
    .DESCRIPTION
        Retreives asset memory lane
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER DayOfMonth
        Defines which day of month to query
    .PARAMETER Month
        Defines which month
    .EXAMPLE
        Get-IMAssetMemoryLane -DayOfMonth 1 -Month 4

        Retreives assets for 1 of April for every year
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidateRange(1, 31)]
        [int]
        $DayOfMonth,

        [Parameter(Mandatory)]
        [ValidateRange(1, 12)]
        [int]
        $Month
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'DayOfMonth', 'Month' -NameMapping @{
                DayOfMonth = 'day'
                Month      = 'month'
            })
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Get -RelativePath '/assets/memory-lane' -ImmichSession:$Session -QueryParameters $QueryParameters | ForEach-Object {
            $PSItem.assets | ForEach-Object { $null = $PSItem | AddCustomType IMAsset }
            $PSItem
        }
    }
}
#endregion
#EndRegion './Public/Asset/Get-IMAssetMemoryLane.ps1' 55
#Region './Public/Asset/Get-IMAssetStatistic.ps1' -1

function Get-IMAssetStatistic
{
    <#
    .DESCRIPTION
        Retreives asset statistic
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER isArchived
        Archived filter
    .PARAMETER isFavorite
        Favorite filter
    .PARAMETER isTrashed
        Trashed filter
    .EXAMPLE
        Get-IMAssetStatistic

        Retreives asset statistic
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [boolean]
        $isArchived,

        [Parameter()]
        [boolean]
        $isFavorite,

        [Parameter()]
        [boolean]
        $isTrashed
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'isArchived', 'isFavorite', 'isTrashed')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Get -RelativePath '/assets/statistics' -ImmichSession:$Session -QueryParameters $QueryParameters
    }
}
#endregion
#EndRegion './Public/Asset/Get-IMAssetStatistic.ps1' 53
#Region './Public/Asset/Import-IMAsset.ps1' -1

function Import-IMAsset
{
    <#
    .DESCRIPTION
        Imports an Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER FilePath
        Defines the path to the file to upload. Accepts pipeline input.
    .PARAMETER Duration
        Defines the duration if its a video asset
    .PARAMETER isArchived
        Defines if the new asset should be archived.
    .PARAMETER isFavorite
        Defines if the new asset should be a favorite
    .PARAMETER isOffline
        Defines if the new asset should be offline
    .PARAMETER isReadOnly
        Defines if the new asset should be read only
    .PARAMETER isVisible
        Defines if the new asset should be visible
    .PARAMETER libraryId
        Defines which library to upload the asset to
    .EXAMPLE
        Import-IMAsset -FilePath C:\file.jpg

        Uploads image to Immich
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP, retreived through PSBoundParameters')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [System.IO.FileInfo[]]
        $FilePath,

        [Parameter()]
        [string]
        $Duration,

        [Parameter()]
        [switch]
        $isArchived,

        [Parameter()]
        [switch]
        $isFavorite ,

        [Parameter()]
        [switch]
        $isOffline ,

        [Parameter()]
        [switch]
        $isReadOnly,

        [Parameter()]
        [switch]
        $isVisible,

        [Parameter()]
        [string]
        $libraryId

    )

    BEGIN
    {
        # Do not run on Windows Powershell
        if ($PSVersionTable.PSEdition -eq 'Desktop')
        {
            Write-Warning -Message 'Import-IMAsset is not currently supported on Windows Powershell, please use Powershell Core instead.'
            break
        }
    }

    PROCESS
    {
        $FilePath | ForEach-Object {
            $FileInfo = Get-Item -Path $PSItem.FullName
            $Uri = "$($ImmichSession.ApiUri)/assets"
            $Header = @{
                'Accept'    = 'application/json'
                'x-api-key' = ConvertFromSecureString -SecureString $ImmichSession.AccessToken
            }
            $Form = @{}
            $Form += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Duration', 'isArchived', 'isFavorite', 'isOffline', 'isReadOnly', 'isVisible', 'libraryId')
            $Form += @{
                deviceAssetId  = $FileInfo.Name
                deviceId       = 'PSImmich'
                fileCreatedAt  = $FileInfo.CreationTime.ToString('yyyy-MM-ddTHH:mm:ss')
                fileModifiedAt = $FileInfo.LastWriteTime.ToString('yyyy-MM-ddTHH:mm:ss')
                assetData      = $FileInfo
            }
            $Result = Invoke-WebRequest -Uri $Uri -Method Post -Headers $Header -Form $Form -ContentType 'multipart/form-data'
            $Result.Content | ConvertFrom-Json | Get-IMAsset
        }
    }
}
#EndRegion './Public/Asset/Import-IMAsset.ps1' 105
#Region './Public/Asset/Remove-IMAsset.ps1' -1

function Remove-IMAsset
{
    <#
    .DESCRIPTION
        Removes an Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER ids
        Defines the asset ids that should be removed. Accepts pipeline input.
    .PARAMETER force
        Performs a hard delete bypassing the Trash
    .EXAMPLE
        Remove-IMAsset -ids <assetid>

        Removes an Immich asset
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        [Alias('id')]
        $ids,

        [Parameter()]
        [switch]
        $force
    )

    BEGIN
    {
        $BodyParameters = @{
            ids = @()
        }
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'force')
    }

    PROCESS
    {
        $ids | ForEach-Object {
            $BodyParameters.ids += $psitem
        }
    }

    END
    {
        if ($PSCmdlet.ShouldProcess(($BodyParameters.ids -join ','), 'DELETE'))
        {
            InvokeImmichRestMethod -Method Delete -RelativePath '/assets' -ImmichSession:$Session -Body:$BodyParameters
        }
    }

}
#endregion
#EndRegion './Public/Asset/Remove-IMAsset.ps1' 62
#Region './Public/Asset/Restore-IMAsset.ps1' -1

function Restore-IMAsset
{
    <#
    .DESCRIPTION
        Restore asset from trash
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines an asset id to restore
    .PARAMETER All
        Defines that all assets in trash should be restored.
    .EXAMPLE
        Restore-IMAsset -id <assetid>

        Restore asset from trash
    .EXAMPLE
        Restore-IMAsset -All

        Restores all assets from trash
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess, DefaultParameterSetName = 'id')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline, ParameterSetName = 'id')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('assetId')]
        [string[]]
        $id,

        [Parameter(Mandatory, ParameterSetName = 'all')]
        [switch]
        $All
    )

    BEGIN
    {
        if ($PSCmdlet.ParameterSetName -eq 'id')
        {
            $AssetIDs = [System.Collections.Generic.List[string]]::New()
        }
    }

    PROCESS
    {
        if ($PSCmdlet.ParameterSetName -eq 'id')
        {
            $id | ForEach-Object {
                $AssetIDs.Add($PSItem)
            }
        }
    }

    END
    {
        switch ($PSCMdlet.ParameterSetName)
        {
            'id'
            {
                if ($PSCmdlet.ShouldProcess(($AssetIDs -join ','), 'Restore'))
                {
                    $BodyParameters = @{
                        ids = ($AssetIDs -as [string[]])
                    }
                    InvokeImmichRestMethod -Method POST -RelativePath '/trash/restore/assets' -ImmichSession:$Session -Body:$BodyParameters
                }
            }
            'all'
            {
                if ($PSCmdlet.ShouldProcess('All trashed assets', 'Restore'))
                {
                    InvokeImmichRestMethod -Method POST -RelativePath '/trash/restore' -ImmichSession:$Session
                }
            }
        }
    }
}
#endregion
#EndRegion './Public/Asset/Restore-IMAsset.ps1' 84
#Region './Public/Asset/Save-IMAsset.ps1' -1

function Save-IMAsset
{
    <#
    .DESCRIPTION
        Save Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific asset id to be retreived
    .PARAMETER isThumb
        Defines if faviorites should be returned or not. Do not specify if either should be returned.
    .PARAMETER isWeb
        Defines if archvied assets should be returned or not. Do not specify if either should be returned.
    .PARAMETER Path
        Defines the directory for the output file
    .EXAMPLE
        Save-IMAsset -id <assetid> -Path C:\download

        Save asset
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter()]
        [switch]
        $isThumb,

        [Parameter()]
        [switch]
        $isWeb,

        [Parameter()]
        [System.IO.DirectoryInfo]
        $Path
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'isThumb', 'isWeb')
    }

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            $AssetObject = Get-IMAsset -Id $CurrentID
            $OutputPath = Join-Path -Path $Path -ChildPath $AssetObject.originalFileName
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $SavedProgressPreference = $global:ProgressPreference
                $global:ProgressPreference = 'SilentlyContinue'
            }
            InvokeImmichRestMethod -Method Get -RelativePath "/assets/$CurrentID/original" -ImmichSession:$Session -QueryParameters $QueryParameters -ContentType 'application/octet-stream' -OutFilePath $OutputPath
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $global:ProgressPreference = $SavedProgressPreference
            }
        }
    }

}
#endregion
#EndRegion './Public/Asset/Save-IMAsset.ps1' 75
#Region './Public/Asset/Set-IMAsset.ps1' -1

function Set-IMAsset
{
    <#
    .DESCRIPTION
        Updates an Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the asset to update
    .PARAMETER dateTimeOriginal
        Defines the assets taken date
    .PARAMETER isArchived
        Defines if the asset should archived
    .PARAMETER isFavorite
        Defines if the asset should be set as favorite
    .PARAMETER latitude
        Set location latitude
    .PARAMETER longitude
        Set location longitude
    .PARAMETER removeParent
        Defines if stack parent should be removed
    .PARAMETER stackParentId
        Defines a parent asset
    .PARAMETER description
        Defines a description
    .PARAMETER AddToAlbum
        Defines if the asset should be added to an album
    .PARAMETER RemoveFromAlbum
        Defines if the asset should be removed from an album
    .PARAMETER AddTag
        Defines if a tag should be added to the asset
    .PARAMETER RemoveTag
        Defines if a tag should be removed from the asset
    .PARAMETER AddToFace
        Defines if the asset should be assign to a face
    .PARAMETER AddToMemory
        Defines if the asset should be added to a memory
    .PARAMETER RemoveFromMemory
        Defines if the asset should be removed from a memory
    .EXAMPLE
        Set-IMAsset -id <assetid> -AddTag <tagid>

        Adds a tag to an asset
    #>

    [CmdletBinding(SupportsShouldProcess, DefaultParameterSetName = 'batch')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline, ParameterSetName = 'batch')]
        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline, ParameterSetName = 'id')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('ids')]
        [string[]]
        $id,

        [Parameter(ParameterSetName = 'batch')]
        [Parameter(ParameterSetName = 'id')]
        [string]
        $dateTimeOriginal,

        [Parameter(ParameterSetName = 'batch')]
        [Parameter(ParameterSetName = 'id')]
        [boolean]
        $isArchived,

        [Parameter(ParameterSetName = 'batch')]
        [Parameter(ParameterSetName = 'id')]
        [boolean]
        $isFavorite,

        [Parameter(ParameterSetName = 'batch')]
        [Parameter(ParameterSetName = 'id')]
        [Int32]
        $latitude,

        [Parameter(ParameterSetName = 'batch')]
        [Parameter(ParameterSetName = 'id')]
        [int32]
        $longitude,

        [Parameter(ParameterSetName = 'batch')]
        [switch]
        $removeParent,

        [Parameter(ParameterSetName = 'batch')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $stackParentId,

        [Parameter(ParameterSetName = 'id')]
        [string]
        $description,

        [Parameter()]
        [string]
        $AddToAlbum,

        [Parameter()]
        [string]
        $RemoveFromAlbum,

        [Parameter()]
        [string]
        $AddTag,

        [Parameter()]
        [string]
        $RemoveTag,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $AddToFace,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $AddToMemory,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $RemoveFromMemory

    )

    BEGIN
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'batch'
            {
                $BodyParameters = @{
                    ids = @()
                }
                $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'dateTimeOriginal', 'isFavorite', 'isArchived', 'latitude', 'longitude', 'removeParent', 'stackParentId')
            }
            'id'
            {
                $BodyParameters = @{}
                $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'dateTimeOriginal', 'isFavorite', 'isArchived', 'latitude', 'longitude', 'description')
            }
        }
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'batch'
            {
                $id | ForEach-Object {
                    $BodyParameters.ids += $psitem
                }
            }
            'id'
            {
                foreach ($object in $id)
                {
                    if ($PSCmdlet.ShouldProcess(($BodyParameters.ids -join ','), 'PUT'))
                    {
                        InvokeImmichRestMethod -Method Put -RelativePath "/assets/$object" -ImmichSession:$Session -Body:$BodyParameters
                        if ($PSBoundParameters.ContainsKey('AddToAlbum'))
                        {
                            $null = InvokeImmichRestMethod -Method PUT -RelativePath "/albums/$AddToAlbum/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                        }
                        if ($PSBoundParameters.ContainsKey('RemoveFromAlbum'))
                        {
                            $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/albums/$RemoveFromAlbum/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                        }
                        if ($PSBoundParameters.ContainsKey('AddTag'))
                        {
                            $null = InvokeImmichRestMethod -Method PUT -RelativePath "/tags/$AddTag/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                        }
                        if ($PSBoundParameters.ContainsKey('RemoveTag'))
                        {
                            $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/tags/$AddTag/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                        }
                        if ($PSBoundParameters.ContainsKey('AddToFace'))
                        {
                            $null = InvokeImmichRestMethod -Method PUT -RelativePath "/faces/$AddToFace" -ImmichSession:$Session -Body:@{id = [string[]]$object }
                        }
                        if ($PSBoundParameters.ContainsKey('AddToMemory'))
                        {
                            $null = InvokeImmichRestMethod -Method PUT -RelativePath "/memories/$AddToMemory/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                        }
                        if ($PSBoundParameters.ContainsKey('RemoveFromMemory'))
                        {
                            $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/memories/$RemoveFromMemory/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                        }
                    }
                }
            }
        }
    }

    END
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'batch'
            {
                if ($PSCmdlet.ShouldProcess(($BodyParameters.ids -join ','), 'PUT'))
                {
                    InvokeImmichRestMethod -Method Put -RelativePath '/assets' -ImmichSession:$Session -Body:$BodyParameters
                    if ($PSBoundParameters.ContainsKey('AddToAlbum'))
                    {
                        $null = InvokeImmichRestMethod -Method PUT -RelativePath "/albums/$AddToAlbum/assets" -ImmichSession:$Session -Body:@{ids = [string[]]($BodyParameters.ids) }
                    }
                    if ($PSBoundParameters.ContainsKey('RemoveFromAlbum'))
                    {
                        $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/albums/$RemoveFromAlbum/assets" -ImmichSession:$Session -Body:@{ids = [string[]]($BodyParameters.ids) }
                    }
                    if ($PSBoundParameters.ContainsKey('AddTag'))
                    {
                        $null = InvokeImmichRestMethod -Method PUT -RelativePath "/tags/$AddTag/assets" -ImmichSession:$Session -Body:@{ids = [string[]]($BodyParameters.ids) }
                    }
                    if ($PSBoundParameters.ContainsKey('RemoveTag'))
                    {
                        $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/tags/$RemoveTag/assets" -ImmichSession:$Session -Body:@{ids = [string[]]($BodyParameters.ids) }
                    }
                    if ($PSBoundParameters.ContainsKey('AddToFace'))
                    {
                        $null = InvokeImmichRestMethod -Method PUT -RelativePath "/faces/$AddToFace" -ImmichSession:$Session -Body:@{id = [string[]]($BodyParameters.ids) }
                    }
                    if ($PSBoundParameters.ContainsKey('AddToMemory'))
                    {
                        $null = InvokeImmichRestMethod -Method PUT -RelativePath "/memories/$AddToMemory/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                    }
                    if ($PSBoundParameters.ContainsKey('RemoveFromMemory'))
                    {
                        $null = InvokeImmichRestMethod -Method DELETE -RelativePath "/memories/$RemoveFromMemory/assets" -ImmichSession:$Session -Body:@{ids = [string[]]$object }
                    }

                }
            }
        }
    }

}
#endregion
#EndRegion './Public/Asset/Set-IMAsset.ps1' 247
#Region './Public/Asset/Start-IMVideoTranscode.ps1' -1

function Start-IMVideoTranscode
{
    <#
    .DESCRIPTION
        Recreates the transcoded version of the source video files
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the asset id that the job should target. Accepts pipeline input.
    .EXAMPLE
        Start-IMVideoTranscode

        Recreates the transcoded version of the source video files
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    BEGIN
    {
        $BodyParameters = @{
            assetIds = @()
            name     = 'transcode-video'
        }
    }

    PROCESS
    {
        $id | ForEach-Object {
            $BodyParameters.assetIds += $psitem
        }
    }

    END
    {
        if ($PSCmdlet.ShouldProcess(($BodyParameters.assetIds -join ','), 'Transcode videos'))
        {
            InvokeImmichRestMethod -Method POST -RelativePath '/assets/jobs' -ImmichSession:$Session -Body:$BodyParameters
        }
    }

}
#endregion
#EndRegion './Public/Asset/Start-IMVideoTranscode.ps1' 55
#Region './Public/Asset/Update-IMAssetMetadata.ps1' -1

function Update-IMAssetMetadata
{
    <#
    .DESCRIPTION
        Update IM asset metadata
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the asset ids that metadata should be refreshed for. Accepts pipeline input.
    .EXAMPLE
        Update-IMAssetMetadata -id <assetid>

        Update IM asset metadata
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseSingularNouns','', Justification='FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    BEGIN
    {
        $BodyParameters = @{
            assetIds = @()
            name     = 'refresh-metadata'
        }
    }

    PROCESS
    {
        $id | ForEach-Object {
            $BodyParameters.assetIds += $psitem
        }
    }

    END
    {
        if ($PSCmdlet.ShouldProcess(($BodyParameters.assetIds -join ','), 'Update metadata'))
        {
            InvokeImmichRestMethod -Method POST -RelativePath '/assets/jobs' -ImmichSession:$Session -Body:$BodyParameters
        }
    }

}
#endregion
#EndRegion './Public/Asset/Update-IMAssetMetadata.ps1' 55
#Region './Public/Asset/Update-IMAssetThumbnail.ps1' -1

function Update-IMAssetThumbnail
{
    <#
    .DESCRIPTION
        Update IM asset thumbnails
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the asset ids that thumbnails should be refreshed for. Accepts pipeline input.
    .EXAMPLE
        Update-IMAssetThumbnail -id <assetid>

        Update IM asset thumbnails
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    BEGIN
    {
        $BodyParameters = @{
            assetIds = @()
            name     = 'regenerate-thumbnail'
        }
    }

    PROCESS
    {
        $id | ForEach-Object {
            $BodyParameters.assetIds += $psitem
        }
    }

    END
    {
        if ($PSCmdlet.ShouldProcess(($BodyParameters.assetIds -join ','), 'Update thumbnail'))
        {
            InvokeImmichRestMethod -Method POST -RelativePath '/assets/jobs' -ImmichSession:$Session -Body:$BodyParameters
        }
    }

}
#endregion
#EndRegion './Public/Asset/Update-IMAssetThumbnail.ps1' 55
#Region './Public/Audit/Get-IMAuditDelete.ps1' -1

function Get-IMAuditDelete
{
    <#
    .DESCRIPTION
        Retreives Immich audit deletes
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER after
        Defines after date filter
    .PARAMETER entityType
        Defines an entity type, ASSET or ALBUM
    .PARAMETER userId
        Defines a user filter
    .EXAMPLE
        Get-IMAuditDelete

        Retreives Immich audit deletes
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $userId,

        [Parameter(Mandatory)]
        [datetime]
        $after,

        [Parameter(Mandatory)]
        [ValidateSet('ASSET', 'ALBUM')]
        [string]
        $entityType
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'userId', 'after', 'entityType')
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Get -RelativePath '/audit/deletes' -ImmichSession:$Session -QueryParameters:$QueryParameters
    }

}
#endregion
#EndRegion './Public/Audit/Get-IMAuditDelete.ps1' 56
#Region './Public/Auth/Test-IMAccessToken.ps1' -1

function Test-IMAccessToken
{
    <#
    .DESCRIPTION
        Verifies that the provided access token is valid
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Test-IMAccessToken

        Verifies that the provided access token is valid
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding()]
    [OutputType([boolean])]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    $Result = InvokeImmichRestMethod -Method POST -RelativePath '/auth/validateToken' -ImmichSession:$Session
    if ($Result)
    {
        return $Result.AuthStatus
    }
    else
    {
        return $false
    }
}
#endregion
#EndRegion './Public/Auth/Test-IMAccessToken.ps1' 35
#Region './Public/AuthSession/Get-IMAuthSession.ps1' -1

function Get-IMAuthSession
{
    <#
    .DESCRIPTION
        Get authenticated sessions
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMAuthDevice

        Get authorized devices
    .NOTES
        Due to Get-IMSession already being used by the PSImmich module, cmdlets within the session namespace is prefixed with "Auth".
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    InvokeImmichRestMethod -Method GET -RelativePath '/sessions' -ImmichSession:$Session
}
#endregion
#EndRegion './Public/AuthSession/Get-IMAuthSession.ps1' 28
#Region './Public/AuthSession/Remove-IMAuthSession.ps1' -1

function Remove-IMAuthSession
{
    <#
    .DESCRIPTION
        Remove one or many auth sessions. Not that if id is not specified all but the current auth session will be purged.
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a uuid of an auth session that should be removed
    .EXAMPLE
        Remove-IMAuthSession

        Remove all auth session (except current)
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'list', SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id

    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            switch ($PSCmdlet.ParameterSetName)
            {
                'list'
                {
                    if ($PSCmdlet.ShouldProcess('All auth sessions', 'DELETE'))
                    {
                        InvokeImmichRestMethod -Method DELETE -RelativePath '/sessions' -ImmichSession:$Session
                    }
                }
                'id'
                {
                    if ($PSCmdlet.ShouldProcess($CurrentID, 'DELETE'))
                    {
                        InvokeImmichRestMethod -Method DELETE -RelativePath "/sessions/$CurrentID" -ImmichSession:$Session
                    }
                }
            }
        }
    }
}
#endregion
#EndRegion './Public/AuthSession/Remove-IMAuthSession.ps1' 56
#Region './Public/Duplicates/Get-IMDuplicate.ps1' -1

function Get-IMDuplicate
{
    <#
    .DESCRIPTION
        Retreives Immich asset duplicate
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMDuplicate

        Retreives Immich asset duplicate
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath "/duplicates" -ImmichSession:$Session | AddCustomType -Type IMAssetDuplicate

}
#endregion
#EndRegion './Public/Duplicates/Get-IMDuplicate.ps1' 27
#Region './Public/Face/Get-IMFace.ps1' -1

function Get-IMFace
{
    <#
    .DESCRIPTION
        Get immich face
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the asset id to get faces for
    .EXAMPLE
        Get-IMFace

        Get immich face
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('assetId')]
        [string[]]
        $id

    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            $QueryParameters = @{
                id = $CurrentID
            }
            InvokeImmichRestMethod -Method GET -RelativePath '/faces' -ImmichSession:$Session -QueryParameters:$QueryParameters
        }
    }
}
#endregion
#EndRegion './Public/Face/Get-IMFace.ps1' 44
#Region './Public/FileReport/Get-IMAuditFile.ps1' -1

function Get-IMAuditFile
{
    <#
    .DESCRIPTION
        Retreives Immich audit files
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMAuditFile

        Retreives Immich audit files
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/reports' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/FileReport/Get-IMAuditFile.ps1' 27
#Region './Public/FileReport/Get-IMFileChecksum.ps1' -1

function Get-IMFileChecksum
{
    <#
    .DESCRIPTION
        Retreives Immich file checksum
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER FileName
        Defines the full path to the file that checksum should be calculated for.
    .EXAMPLE
        Get-IMFileChecksum

        Retreives Immich file checksum
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string[]]
        $FileName
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'FileName' -NameMapping @{FileName = 'filenames' })
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method POST -RelativePath '/reports/checksum' -ImmichSession:$Session -Body:$BodyParameters
    }

}
#endregion
#EndRegion './Public/FileReport/Get-IMFileChecksum.ps1' 42
#Region './Public/Job/Clear-IMJob.ps1' -1

function Clear-IMJob
{
    <#
    .DESCRIPTION
        Clear immich job
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Job
        Defines the job type
    .PARAMETER Force
        Defines force
    .PARAMETER FailedOnly
        Defines that only failed jobs should be cleared
    .EXAMPLE
        Clear-IMJob

        Clear immich job
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidateSet(
            'thumbnailGeneration',
            'metadataExtraction',
            'videoConversion',
            'faceDetection',
            'facialRecognition',
            'smartSearch',
            'duplicateDetection',
            'backgroundTask',
            'storageTemplateMigration',
            'migration',
            'search',
            'sidecar',
            'library',
            'notifications'
        )]
        [string[]]
        $Job,

        [Parameter()]
        [switch]
        $FailedOnly,

        [Parameter()]
        [switch]
        $Force
    )

    $Job | ForEach-Object {
        $CurrentJob = $PSItem
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Force')
        if ($FailedOnly)
        {
            $Body += @{command = 'clear-failed' }
        }
        else
        {
            $Body += @{command = 'empty' }
        }
        InvokeImmichRestMethod -Method PUT -RelativePath "/jobs/$CurrentJob" -ImmichSession:$Session -Body:$Body
    }
}
#endregion
#EndRegion './Public/Job/Clear-IMJob.ps1' 73
#Region './Public/Job/Get-IMJob.ps1' -1

function Get-IMJob
{
    <#
    .DESCRIPTION
        Get immich job
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMJob

        Get immich job
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    InvokeImmichRestMethod -Method GET -RelativePath '/jobs' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Job/Get-IMJob.ps1' 27
#Region './Public/Job/Resume-IMJob.ps1' -1

function Resume-IMJob
{
    <#
    .DESCRIPTION
        Resume immich job
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Job
        Defines the job type
    .PARAMETER Force
        Defines force
    .EXAMPLE
        Resume-IMJob

        Resume immich job
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidateSet(
            'thumbnailGeneration',
            'metadataExtraction',
            'videoConversion',
            'faceDetection',
            'facialRecognition',
            'smartSearch',
            'duplicateDetection',
            'backgroundTask',
            'storageTemplateMigration',
            'migration',
            'search',
            'sidecar',
            'library',
            'notifications'
        )]
        [string[]]
        $Job,

        [Parameter()]
        [switch]
        $Force
    )

    $Job | ForEach-Object {
        $CurrentJob = $PSItem
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Force')
        $Body += @{command = 'resume' }
        InvokeImmichRestMethod -Method PUT -RelativePath "/jobs/$CurrentJob" -ImmichSession:$Session -Body:$Body
    }
}
#endregion
#EndRegion './Public/Job/Resume-IMJob.ps1' 60
#Region './Public/Job/Start-IMJob.ps1' -1

function Start-IMJob
{
    <#
    .DESCRIPTION
        Start immich job
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Job
        Defines the job type
    .PARAMETER Force
        Define force
    .EXAMPLE
        Start-IMJob -job 'thumbnailGeneration'

        Start thumbnail generation job
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidateSet(
            'thumbnailGeneration',
            'metadataExtraction',
            'videoConversion',
            'faceDetection',
            'facialRecognition',
            'smartSearch',
            'duplicateDetection',
            'backgroundTask',
            'storageTemplateMigration',
            'migration',
            'search',
            'sidecar',
            'library',
            'notifications',
            'emptyTrash',
            'person-cleanup',
            'tag-cleanup',
            'user-cleanup'
        )]
        [string[]]
        $Job,

        [Parameter()]
        [switch]
        $Force
    )

    $Job | ForEach-Object {
        switch ($PSItem)
        {
            'emptyTrash'
            {
                if ($PSCmdlet.ShouldProcess('All assets in trash', 'REMOVE'))
                {
                    InvokeImmichRestMethod -Method POST -RelativePath '/trash/empty' -ImmichSession:$Session
                }
            }
            { @('person-cleanup', 'tag-cleanup', 'user-cleanup') -contains $PSItem }
            {
                if ($PSCmdlet.ShouldProcess("Start job: $($PSitem)", 'START'))
                {
                    $Body = @{
                        name = $PSitem
                    }
                    InvokeImmichRestMethod -Method POST -RelativePath '/jobs' -ImmichSession:$Session -Body:$Body
                }
            }
            default
            {
                if ($PSCmdlet.ShouldProcess("Start job: $($PSitem)", 'START'))
                {
                    $CurrentJob = $PSItem
                    $Body = @{}
                    $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Force')
                    $Body += @{
                        command = 'start'
                    }
                    InvokeImmichRestMethod -Method PUT -RelativePath "/jobs/$CurrentJob" -ImmichSession:$Session -Body:$Body
                }
            }
        }
    }
}
#endregion
#EndRegion './Public/Job/Start-IMJob.ps1' 93
#Region './Public/Job/Suspend-IMJob.ps1' -1

function Suspend-IMJob
{
    <#
    .DESCRIPTION
        Suspend immich job
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Job
        Defines the job type to pause
    .PARAMETER Force
        Defines force
    .EXAMPLE
        Suspend-IMJob -job 'thumbnailGeneration'

        Suspend immich job
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidateSet(
            'thumbnailGeneration',
            'metadataExtraction',
            'videoConversion',
            'faceDetection',
            'facialRecognition',
            'smartSearch',
            'duplicateDetection',
            'backgroundTask',
            'storageTemplateMigration',
            'migration',
            'search',
            'sidecar',
            'library',
            'notifications'
        )]
        [string[]]
        $Job,

        [Parameter()]
        [switch]
        $Force
    )

    $Job | ForEach-Object {
        $CurrentJob = $PSItem
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Force')
        $Body += @{command = 'pause' }
        InvokeImmichRestMethod -Method PUT -RelativePath "/jobs/$CurrentJob" -ImmichSession:$Session -Body:$Body
    }
}
#endregion
#EndRegion './Public/Job/Suspend-IMJob.ps1' 60
#Region './Public/Library/Get-IMLibrary.ps1' -1

function Get-IMLibrary
{
    <#
    .DESCRIPTION
        Retreives Immich library
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific library id to be retreived
    .PARAMETER ownerId
        Retreive libraries for a user
    .PARAMETER IncludeStatistics
        Includes statistics for the library in the return object
    .EXAMPLE
        Get-IMLibrary

        Retreives Immich library
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter(ParameterSetName = 'id')]
        [switch]
        $IncludeStatistics,

        [Parameter(ParameterSetName = 'list')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $ownerId
    )

    PROCESS
    {
        if ($PSCmdlet.ParameterSetName -eq 'id')
        {
            $id | ForEach-Object {
                $CurrentID = $PSItem
                $Result = InvokeImmichRestMethod -Method Get -RelativePath "/libraries/$CurrentID" -ImmichSession:$Session
                if ($IncludeStatistics)
                {
                    $Stats = InvokeImmichRestMethod -Method GET -RelativePath "/libraries/$CurrentID/statistics" -ImmichSession:$Session
                    $Result | Add-Member -MemberType NoteProperty -Name 'Statistics' -Value $Stats
                }
                $Result
            }
        }
    }

    END
    {
        if ($PSCmdlet.ParameterSetName -eq 'list')
        {
            if ($ownerId)
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/libraries' -ImmichSession:$Session | Where-Object { $_.ownerid -eq $ownerid }
            }
            else
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/libraries' -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/Library/Get-IMLibrary.ps1' 76
#Region './Public/Library/New-IMLibrary.ps1' -1

function New-IMLibrary
{
    <#
    .DESCRIPTION
        Adds a new library
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER name
        Defines the name of the library
    .PARAMETER exclusionPatterns
        Defines an exclusion pattern
    .PARAMETER importPaths
        Defines the import paths
    .PARAMETER ownerId
        Defines the owner of library
    .EXAMPLE
        New-IMLibrary -Name 'NAS' -ImportPaths '/mnt/media/pictures'

        Adds a new library
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Do not agree, new initiates an entity not previously known to the system, that should not cause issues.')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string]
        $name,

        [Parameter()]
        [string[]]
        $exclusionPatterns,

        [Parameter()]
        [string[]]
        $importPaths,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $ownerId
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'name', 'exclusionPatterns', 'importPaths', 'isVisible', 'isWatched', 'ownerId', 'type')

    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Post -RelativePath '/libraries' -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/Library/New-IMLibrary.ps1' 62
#Region './Public/Library/Remove-IMLibrary.ps1' -1

function Remove-IMLibrary
{
    <#
    .DESCRIPTION
        Removes an Immich library
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the library ids that should be removed. Accepts pipeline input.
    .EXAMPLE
        Remove-IMLibrary -id <libraryid>

        Removes an Immich library
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('libraryId')]
        [string[]]
        $id
    )

    PROCESS
    {
        # We loop through IDs because ids can be provided as an array to the parameter in which case the process block only gets called once.
        $id | ForEach-Object {
            $CurrentID = $PSItem
            if ($PSCmdlet.ShouldProcess($CurrentID, 'DELETE'))
            {
                InvokeImmichRestMethod -Method Delete -RelativePath "/libraries/$CurrentID" -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/Library/Remove-IMLibrary.ps1' 44
#Region './Public/Library/Set-IMLibrary.ps1' -1

function Set-IMLibrary
{
    <#
    .DESCRIPTION
        Updates an Immich library
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines library to update
    .PARAMETER exclusionPatterns
        Defines exclusion patterns
    .PARAMETER importPaths
        Defines import paths
    .PARAMETER isVisible
        Defines if the library should be visible
    .PARAMETER name
        Defines the name of the library
    .EXAMPLE
        Set-IMLibrary -id <libraryid> -Name 'NewName'

        Update an Immich library
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [string[]]
        $exclusionPatterns,

        [Parameter()]
        [string[]]
        $importPaths,

        [Parameter()]
        [boolean]
        $isVisible,

        [Parameter()]
        [string]
        $name
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'exclusionPatterns', 'importPaths', 'isVisible', 'name')
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'Update'))
            {
                InvokeImmichRestMethod -Method PUT -RelativePath "/libraries/$PSItem" -ImmichSession:$Session -Body:$BodyParameters
            }
        }
    }
}
#endregion
#EndRegion './Public/Library/Set-IMLibrary.ps1' 71
#Region './Public/Library/Sync-IMLibrary.ps1' -1

function Sync-IMLibrary
{
    <#
    .DESCRIPTION
        Start library scan job
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific library id to be cleaned up
    .PARAMETER refreshAllFiles
        Defines if all assets should be scanned. Default false
    .PARAMETER refreshModifiedFiles
        Defines that only new/modified assets should be scanned. Default true
    .EXAMPLE
        Sync-IMLibrary -id <libraryid>

        Start library scan job
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'FP')]
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [boolean]
        $refreshAllFiles = $false,

        [Parameter()]
        [boolean]
        $refreshModifiedFiles = $true
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            InvokeImmichRestMethod -Method POST -RelativePath "/libraries/$CurrentID/scan" -ImmichSession:$Session
        }

    }
}
#endregion
#EndRegion './Public/Library/Sync-IMLibrary.ps1' 53
#Region './Public/Library/Test-IMLibrary.ps1' -1

function Test-IMLibrary
{
    <#
    .DESCRIPTION
        Validate library
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines libraries to validate
    .PARAMETER exclusionPatterns
        Defines exlusion patterns
    .PARAMETER importPaths
        Defines import paths
    .EXAMPLE
        Test-IMLibrary -id <libraryid>

       Validate library
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [string[]]
        $exclusionPatterns,

        [Parameter()]
        [string[]]
        $importPaths
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'exclusionPatterns', 'importPaths')
    }

    PROCESS
    {
        $id | ForEach-Object {
            InvokeImmichRestMethod -Method POST -RelativePath "/libraries/$PSItem/validate" -ImmichSession:$Session -Body:$BodyParameters
        }
    }
}
#endregion
#EndRegion './Public/Library/Test-IMLibrary.ps1' 56
#Region './Public/Map/Convert-IMCoordinatesToLocation.ps1' -1

function Convert-IMCoordinatesToLocation
{
    <#
    .DESCRIPTION
        Converts coordinates to a location
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Latitude
        Defines the latitude part of the coordinate.
    .PARAMETER Longitude
        Defines the longitude part of the coordinate.
    .EXAMPLE
        Convert-IMCoordinatesToLocation -Latitude 51.496637 -Longitude -0.176370

        Converts the specified coordinates to a location.
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [double]
        $Latitude,

        [Parameter(Mandatory)]
        [double]
        $Longitude
    )

    $QueryParameters = @{}
    $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Latitude', 'Longitude' -NameMapping @{
            Latitude  = 'lat'
            Longitude = 'lon'
        })

    InvokeImmichRestMethod -Method Get -RelativePath '/map/reverse-geocode' -ImmichSession:$Session -QueryParameters $QueryParameters

}
#endregion
#EndRegion './Public/Map/Convert-IMCoordinatesToLocation.ps1' 45
#Region './Public/Map/Get-IMMapMarker.ps1' -1

function Get-IMMapMarker
{
    <#
    .DESCRIPTION
        Retreives map markers
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER CreatedAfter
        Created after filter
    .PARAMETER CreatedBefore
        Created before filter
    .PARAMETER IsArchived
        Archived filter
    .PARAMETER IsFavorite
        Favorite filter
    .PARAMETER WithPartners
        With partners filter
    .PARAMETER WithSharedAlbums
        With shared albums filter
    .EXAMPLE
        Get-IMMapMarker

        Retreives map markers
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [datetime]
        $CreatedAfter,

        [Parameter()]
        [datetime]
        $CreatedBefore,

        [Parameter()]
        [boolean]
        $IsArchived,

        [Parameter()]
        [boolean]
        $IsFavorite,

        [Parameter()]
        [boolean]
        $WithPartners,

        [Parameter()]
        [boolean]
        $WithSharedAlbums
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'CreatedAfter', 'CreatedBefore', 'IsArchived', 'IsFavorite', 'WithPartners', 'WithSharedAlbums' -NameMapping @{
                CreatedAfter     = 'fileCreatedAfter'
                CreatedBefore    = 'fileCreatedBefore'
                IsArchived       = 'isArchived'
                IsFavorite       = 'isFavorite'
                WithPartners     = 'withPartners'
                WithSharedAlbums = 'withSharedAlbums'
            })
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Get -RelativePath '/map/markers' -ImmichSession:$Session -QueryParameters $QueryParameters
    }
}
#endregion
#EndRegion './Public/Map/Get-IMMapMarker.ps1' 78
#Region './Public/Map/Get-IMMapStyle.ps1' -1

function Get-IMMapStyle
{
    <#
    .DESCRIPTION
        Retreives Immich map style
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Theme
        Specifies which theme (dark or light) should be returned.
    .EXAMPLE
        Get-IMMapStyle

        Retreives Immich map style
    #>

    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(ParameterSetName = 'mapstyle')]
        [ValidateSet('light', 'dark')]
        [ValidateScript({ $PSItem -ceq 'light' -or $PSItem -ceq 'dark' })]
        [string]
        $Theme
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/map/style.json' -ImmichSession:$Session -QueryParameters:@{theme = $Theme }

}
#endregion
#EndRegion './Public/Map/Get-IMMapStyle.ps1' 36
#Region './Public/Memories/Get-IMMemory.ps1' -1

function Get-IMMemory
{
    <#
    .DESCRIPTION
        Retreives Immich memory
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific memory id to be retreived
    .EXAMPLE
        Get-IMMemory

        Retreives Immich memory
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        if ($PSCmdlet.ParameterSetName -eq 'id')
        {
            $id | ForEach-Object {
                InvokeImmichRestMethod -Method Get -RelativePath "/memories/$PSItem" -ImmichSession:$Session
            }
        }
    }

    END
    {
        if ($PSCmdlet.ParameterSetName -eq 'list')
        {
            InvokeImmichRestMethod -Method Get -RelativePath '/memories' -ImmichSession:$Session
        }
    }
}
#endregion
#EndRegion './Public/Memories/Get-IMMemory.ps1' 49
#Region './Public/Memories/New-IMMemory.ps1' -1

function New-IMMemory
{
    <#
    .DESCRIPTION
        Adds a new memory
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER MemoryAt
        Defines the MemoryAt property
    .PARAMETER SeenAt
        Defines the SeenAt property
    .PARAMETER Type
        Defines the type of memory. Defaults to 'on_this_day'. Valid values are 'on_this_day'
    .PARAMETER Year
        Defines the year of the memory.
    .PARAMETER assetIds
        Defines a list of assets to add to the memory
    .EXAMPLE
        New-IMMemory -MemoryAt "2024-01-01 00:00:00" -assetIds <assetid>,<assetid>

        Create a new memory for the date and assets.
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Do not agree, new initiates an entity not previously known to the system, that should not cause issues.')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [ValidateRange(1, [int]::MaxValue)]
        [boolean]
        $Year,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $AssetIds,

        [Parameter(Mandatory)]
        [datetime]
        $MemoryAt,

        [Parameter()]
        [datetime]
        $SeenAt,

        [Parameter()]
        [ValidateSet('on_this_day')]
        [string]
        $Type = 'on_this_day'
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'MemoryAt', 'SeenAt', 'Type' -NameMapping @{
                MemoryAt = 'memoryAt'
                SeenAt   = 'seenAt'
                Type     = 'type'
            })
        $BodyParameters.assetIds += [string[]]@()
        $BodyParameters.data += [hashtable]@{
            year = $year
        }
    }

    PROCESS
    {
        $AssetIds | ForEach-Object {
            $BodyParameters.assetIds += $PSItem
        }
    }

    END
    {
        InvokeImmichRestMethod -Method Post -RelativePath '/memories' -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/Memories/New-IMMemory.ps1' 84
#Region './Public/Memories/Remove-IMMemory.ps1' -1

function Remove-IMMemory
{
    <#
    .DESCRIPTION
        Removes an Immich memory
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the memory ids that should be removed. Accepts pipeline input.
    .EXAMPLE
        Remove-IMMemory -id <memoryid>

        Removes an Immich memory
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [Alias('libraryId')]
        [string[]]
        $id
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            if ($PSCmdlet.ShouldProcess($CurrentID, 'DELETE'))
            {
                InvokeImmichRestMethod -Method Delete -RelativePath "/memories/$CurrentID" -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/Memories/Remove-IMMemory.ps1' 43
#Region './Public/Memories/Set-IMMemory.ps1' -1

function Set-IMMemory
{
    <#
    .DESCRIPTION
        Updates an Immich memory
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines memory to update
    .PARAMETER isSaved
        Defines if the memory is saved
    .PARAMETER importPaths
        Defines import paths
    .PARAMETER memoryAt
        Defines the memoryAt datetime
    .PARAMETER seenAt
        Defines the seenAt datetime
    .EXAMPLE
        Set-IMMemory -id <memoryid> -memoryAt "2024-01-01 00:00:00"

        Update an Immich memory
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [boolean]
        $isSaved,

        [Parameter()]
        [datetime]
        $MemoryAt,

        [Parameter()]
        [datetime]
        $SeenAt

    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'isSaved', 'MemoryAt', 'SeenAt')
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'Update'))
            {
                InvokeImmichRestMethod -Method PUT -RelativePath "/memories/$PSItem" -ImmichSession:$Session -Body:$BodyParameters
            }
        }
    }
}
#endregion
#EndRegion './Public/Memories/Set-IMMemory.ps1' 68
#Region './Public/Notification/Send-IMTestMessage.ps1' -1

function Send-IMTestMessage
{
    <#
    .DESCRIPTION
        Send a SMTP test message
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER enabled
        Unknown, defaults to true
    .PARAMETER from
        Defines the from address
    .PARAMETER replyTo
        Defines the replyto address
    .PARAMETER hostname
        Defines the smtp host
    .PARAMETER ignoreCert
        Defines if certificate validation should be skipped
    .PARAMETER password
        Defines the password
    .PARAMETER port
        Defines port
    .PARAMETER username
        Defines the username
    .EXAMPLE
        Send-IMTestMessage

        Send a SMTP test message
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Do not agree, new initiates an entity not previously known to the system, that should not cause issues.')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [boolean]
        $enabled = $true,

        [Parameter(Mandatory)]
        [string]
        $from,

        [Parameter(Mandatory)]
        [string]
        $replyto,

        [Parameter(Mandatory)]
        [string]
        $hostname,

        [Parameter()]
        [boolean]
        $ignoreCert = $false,

        [Parameter(Mandatory)]
        [securestring]
        $Password,

        [Parameter()]
        [int]
        $port = 25,

        [Parameter()]
        [string]
        $username = ''
    )

    BEGIN
    {
        $BodyParameters = @{}
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'enabled', 'from', 'replyTo')
        $BodyParameters.transport = [hashtable]@{
            host       = $hostname
            ignoreCert = $ignoreCert
            password   = $password
            port       = $port
            username   = $username
        }
    }

    PROCESS
    {
        InvokeImmichRestMethod -Method Post -RelativePath '/notifications/test-email' -ImmichSession:$Session -Body $BodyParameters
    }

}
#endregion
#EndRegion './Public/Notification/Send-IMTestMessage.ps1' 91
#Region './Public/Partner/Add-IMPartner.ps1' -1

function Add-IMPartner
{
    <#
    .DESCRIPTION
        Add immich partner
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Define the id of the partner to add
    .EXAMPLE
        Add-IMPartner -id <userid>

        Add immich partner
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id
    )

    InvokeImmichRestMethod -Method POST -RelativePath "/partners/$id" -ImmichSession:$Session
}
#endregion
#EndRegion './Public/Partner/Add-IMPartner.ps1' 33
#Region './Public/Partner/Get-IMPartner.ps1' -1

function Get-IMPartner
{
    <#
    .DESCRIPTION
        Get immich partner
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER direction
        Defines the direction of the partnership
    .EXAMPLE
        Get-IMPartner -direction 'shared-with'

        Get immich partner
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidateSet('shared-by', 'shared-with')]
        [string]
        $Direction

    )

    PROCESS
    {
        $QueryParameters = @{
            direction = $Direction
        }
        InvokeImmichRestMethod -Method GET -RelativePath '/partners' -ImmichSession:$Session -QueryParameters:$QueryParameters
    }
}
#endregion
#EndRegion './Public/Partner/Get-IMPartner.ps1' 40
#Region './Public/Partner/Remove-IMPartner.ps1' -1

function Remove-IMPartner
{
    <#
    .DESCRIPTION
        Remove immich partner
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the partner id
    .EXAMPLE
        Remove-IMPartner -id <userid>

        Remove immich partner
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', 'Session', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id
    )
    if ($PSCmdlet.ShouldProcess($id, 'DELETE'))
    {
        InvokeImmichRestMethod -Method DELETE -RelativePath "/partners/$id" -ImmichSession:$Session
    }
}
#endregion
#EndRegion './Public/Partner/Remove-IMPartner.ps1' 35
#Region './Public/Partner/Set-IMPartner.ps1' -1

function Set-IMPartner
{
    <#
    .DESCRIPTION
        Set immich partner
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Define the id of the partner to update
    .PARAMETER EnableTimeline
        Defines that the partners assets should be displayed within the main timeline
    .EXAMPLE
        Set-IMPartner -id <userid> -EnableTimeline

        Set immich partner
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter()]
        [switch]
        $EnableTimeline
    )

    if ($PSCmdlet.ShouldProcess($id, 'Update'))
    {
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'EnableTimeline' -NameMapping @{EnableTimeline = 'inTimeline' })

        InvokeImmichRestMethod -Method PUT -RelativePath "/partners/$id" -ImmichSession:$Session -Body:$Body
    }
}
#endregion
#EndRegion './Public/Partner/Set-IMPartner.ps1' 45
#Region './Public/Person/Export-IMPersonThumbnail.ps1' -1

function Export-IMPersonThumbnail
{
    <#
    .DESCRIPTION
        Export Immich person thumbnail
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the person id to retreive the thumbnail for
    .PARAMETER Path
        Defines the directory for the output file
    .EXAMPLE
        Export-IMPersonThumbnail -id <personid> -Path C:\download

        Export person thumbnail
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter()]
        [System.IO.DirectoryInfo]
        $Path
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            $OutputPath = Join-Path -Path $Path -ChildPath "$($CurrentID).jpeg"
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $SavedProgressPreference = $global:ProgressPreference
                $global:ProgressPreference = 'SilentlyContinue'
            }
            InvokeImmichRestMethod -Method Get -RelativePath "/people/$CurrentID/thumbnail" -ImmichSession:$Session -ContentType 'application/octet-stream' -OutFilePath $OutputPath
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $global:ProgressPreference = $SavedProgressPreference
            }
        }
    }

}
#endregion
#EndRegion './Public/Person/Export-IMPersonThumbnail.ps1' 56
#Region './Public/Person/Get-IMPerson.ps1' -1

function Get-IMPerson
{
    <#
    .DESCRIPTION
        Retreives Immich person
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific person to be retreived
    .PARAMETER withHidden
        Defines if hidden should be returned or not. Do not specify if either should be returned.
    .PARAMETER IncludeStatistics
        Defines if statistics should be returned for the person
    .EXAMPLE
        Get-IMPerson

        Retreives Immich person
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter(ParameterSetName = 'list')]
        [switch]
        $withHidden,

        [Parameter(ParameterSetName = 'id')]
        [switch]
        $IncludeStatistics
    )

    BEGIN
    {
        if ($PSCmdlet.ParameterSetName -eq 'list')
        {
            $QueryParameters = @{}
            $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'withHidden')
        }
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'list'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/people' -ImmichSession:$Session -QueryParameters $QueryParameters
            }
            'id'
            {
                $Person = InvokeImmichRestMethod -Method Get -RelativePath "/people/$id" -ImmichSession:$Session -QueryParameters $QueryParameters
                if ($IncludeStatistics)
                {
                    $PersonStats = InvokeImmichRestMethod -Method Get -RelativePath "/people/$id/statistics" -ImmichSession:$Session
                    $Person | Add-Member -MemberType NoteProperty -Name AssetCount -Value $PersonStats.assets
                }
                $Person
            }
        }
    }
}
#endregion
#EndRegion './Public/Person/Get-IMPerson.ps1' 73
#Region './Public/Person/Merge-IMPerson.ps1' -1

function Merge-IMPerson
{
    <#
    .DESCRIPTION
        Merges two people
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER ToPersonID
        Defines the person to merge to
    .PARAMETER FromPersonID
        Defines the id of the person to merge from
    .EXAMPLE
        Merge-IMPerson -ToPersonID <personid> -FromPersonID <personid>,<personid>

        Merges three persons. ToPersonID will persist
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $ToPersonID,

        [Parameter(Mandatory)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $FromPersonID
    )

    if ($PSCmdlet.ShouldProcess(("Merge people($($FromPersonID -join ',')) with $ToPersonID"), 'POST'))
    {
        $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'FromPersonID' -NameMapping @{
                FromPersonID = 'ids'
            })

        InvokeImmichRestMethod -Method POST -RelativePath "/people/$ToPersonID/merge" -ImmichSession:$Session -Body:$BodyParameters
    }
}
#endregion
#EndRegion './Public/Person/Merge-IMPerson.ps1' 47
#Region './Public/Person/New-IMPerson.ps1' -1

function New-IMPerson
{
    <#
    .DESCRIPTION
        Adds a new Immich person
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER birthDate
        Defines a birthdate for the person
    .PARAMETER isHidden
        Defines if the person is hidden
    .PARAMETER name
        Defines the name of the person
    .EXAMPLE
        New-IMPerson -Name 'John Smith'

        Adds a new Immich person
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string]
        $Name,

        [Parameter()]
        [switch]
        $IsHidden,

        [Parameter()]
        [datetime]
        $BirthDate
    )

    $Body = @{}
    $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'BirthDate', 'IsHidden', 'Name' -namemapping @{BirthDate = 'birthDate'; IsHidden = 'isHidden'; Name = 'name' })
    InvokeImmichRestMethod -Method Post -RelativePath '/people' -ImmichSession:$Session -Body:$Body
}
#endregion
#EndRegion './Public/Person/New-IMPerson.ps1' 46
#Region './Public/Person/Set-IMPerson.ps1' -1

function Set-IMPerson
{
    <#
    .DESCRIPTION
        Updates an Immich asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the person to update
    .PARAMETER BirthDate
        Defines birth date
    .PARAMETER FaceAssetId
        Defines an face asset id
    .PARAMETER IsHidden
        Defines if the person should be hidden
    .PARAMETER Name
        Defines the name of the person
    .EXAMPLE
        Set-IMPerson -id <personid> -Name 'John Smith'

        Update an Immich asset
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $Id,

        [Parameter()]
        [datetime]
        $BirthDate,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $FaceAssetId,

        [Parameter()]
        [boolean]
        $IsHidden,

        [Parameter()]
        [string]
        $Name

    )

    BEGIN
    {
        $ObjectArray = [array]@()
    }

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            $BodyParameters = @{}
            $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'BirthDate', 'FaceAssetId', 'IsHidden', 'Name' -NameMapping @{
                    BirthDate   = 'birthDate'
                    FaceAssetId = 'featureFaceAssetId'
                    IsHidden    = 'isHidden'
                    Name        = 'name'
                })
            $BodyParameters += @{id = $CurrentID }
            $ObjectArray += $BodyParameters
        }
    }

    END
    {
        if ($PSCmdlet.ShouldProcess(($ObjectArray.id -join ','), 'PUT'))
        {
            $BodyResult = @{
                people = $ObjectArray
            }
            InvokeImmichRestMethod -Method Put -RelativePath '/people' -ImmichSession:$Session -Body:$BodyResult
        }
    }

}
#endregion
#EndRegion './Public/Person/Set-IMPerson.ps1' 90
#Region './Public/Search/Find-IMAsset.ps1' -1

function Find-IMAsset
{
    <#
    .DESCRIPTION
        Find assets
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER checksum
        Checksum filter
    .PARAMETER city
        City filter
    .PARAMETER country
        Country filter
    .PARAMETER createdAfter
        CreatedAfter filter
    .PARAMETER createdBefore
        CreatedBefore filter
    .PARAMETER deviceAssetId
        Device Asset Id filter
    .PARAMETER deviceId
        Device Id filter
    .PARAMETER encodedVideoPath
        Encoded Video path filter
    .PARAMETER id
        Id filter
    .PARAMETER isArchived
        Archvied filter
    .PARAMETER isEncoded
        Encoded filter
    .PARAMETER isExternal
        External filter
    .PARAMETER isFavorite
        Favorite filter
    .PARAMETER isMotion
        Motion filter
    .PARAMETER isNotInAlbum
        Not in Album filter
    .PARAMETER isOffline
        Offline filter
    .PARAMETER isReadOnly
        Read only filter
    .PARAMETER isVisible
        Visible filter
    .PARAMETER lensModel
        Lens model filter
    .PARAMETER libraryId
        Library id filter
    .PARAMETER make
        Make filter
    .PARAMETER model
        Model filter
    .PARAMETER order
        Defines sort order
    .PARAMETER originalFileName
        Original file name filter
    .PARAMETER originalPath
        Original path filter
    .PARAMETER personIds
        Person id filter
    .PARAMETER resizePath
        Resize path filter
    .PARAMETER size
        Size of rest call page
    .PARAMETER state
        State filter
    .PARAMETER takenAfter
        Taken after filter
    .PARAMETER takenBefore
        Taken before filter
    .PARAMETER trashedAfter
        Trashed after filter
    .PARAMETER trashedBefore
        Trashed before filter
    .PARAMETER type
        Type filter
    .PARAMETER updatedAfter
        Updated after filter
    .PARAMETER updatedBefore
        Updated before filter
    .PARAMETER webpPath
        Webp path filter
    .PARAMETER withArchived
        Archived filter
    .PARAMETER withDeleted
        Deleted filter
    .PARAMETER withExif
        Exif filter
    .PARAMETER withPeople
        With people filter
    .PARAMETER withStacked
        Stacked filter
    .EXAMPLE
        Find-IMAsset -createdAfter (Get-Date).AddDays(-30)

        Retreives all assets created in the last 30 days
    #>

    [CmdletBinding(DefaultParameterSetName = 'list-shared')]
    param(
        [Parameter()]
        [ImmichSession]$Session = $null,

        [Parameter()]
        [string]$checksum,

        [Parameter()]
        [string]$city,

        [Parameter()]
        [string]$country,

        [Parameter()]
        [datetime]$createdAfter,

        [Parameter()]
        [datetime]$createdBefore,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]$deviceAssetId,

        [Parameter()]
        [string]$deviceId,

        [Parameter()]
        [string]$encodedVideoPath,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]$id,

        [Parameter()]
        [boolean]$isArchived,

        [Parameter()]
        [boolean]$isEncoded,

        [Parameter()]
        [boolean]$isExternal,

        [Parameter()]
        [boolean]$isFavorite,

        [Parameter()]
        [boolean]$isMotion,

        [Parameter()]
        [boolean]$isNotInAlbum,

        [Parameter()]
        [boolean]$isOffline,

        [Parameter()]
        [boolean]$isReadOnly,

        [Parameter()]
        [boolean]$isVisible,

        [Parameter()]
        [string]$lensModel,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]$libraryId,

        [Parameter()]
        [string]$make,

        [Parameter()]
        [string]$model,

        [Parameter()]
        [ValidateSet('asc', 'desc')]
        [string]$order,

        [Parameter()]
        [string]$originalFileName,

        [Parameter()]
        [string]$originalPath,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]$personIds,

        [Parameter()]
        [string]$resizePath,

        [Parameter()]
        [int]$size,

        [Parameter()]
        [string]$state,

        [Parameter()]
        [datetime]$takenAfter,

        [Parameter()]
        [datetime]$takenBefore,

        [Parameter()]
        [datetime]$trashedAfter,

        [Parameter()]
        [datetime]$trashedBefore,

        [Parameter()]
        [ValidateSet('IMAGE', 'VIDEO', 'AUDIO', 'OTHER')]
        [string]$type,

        [Parameter()]
        [datetime]$updatedAfter,

        [Parameter()]
        [datetime]$updatedBefore,

        [Parameter()]
        [string]$webpPath,

        [Parameter()]
        [boolean]$withArchived,

        [Parameter()]
        [boolean]$withDeleted,

        [Parameter()]
        [boolean]$withExif,

        [Parameter()]
        [boolean]$withPeople,

        [Parameter()]
        [boolean]$withStacked
    )

    $Body = @{}
    $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'checksum', 'city', 'country', 'createdAfter', 'createdBefore', 'deviceAssetId', 'deviceId', 'encodedVideoPath', 'id', 'isArchived', 'isEncoded', 'isExternal', 'isFavorite', 'isMotion', 'isNotInAlbum', 'isOffline', 'isReadOnly', 'isVisible', 'lensModel', 'libraryId', 'make', 'model', 'order', 'originalFileName', 'originalPath', 'page', 'personIds', 'resizePath', 'size', 'state', 'takenAfter', 'takenBefore', 'trashedAfter', 'trashedBefore', 'type', 'updatedAfter', 'updatedBefore', 'webpPath', 'withArchived', 'withDeleted', 'withExif', 'withPeople', 'withStacked')

    $Result = InvokeImmichRestMethod -Method POST -RelativePath '/search/metadata' -ImmichSession:$Session -Body $Body | Select-Object -ExpandProperty assets
    $Result | Select-Object -ExpandProperty items | AddCustomType IMAsset

    while ($Result.NextPage)
    {
        $Body.page = $Result.NextPage
        $Result = InvokeImmichRestMethod -Method POST -RelativePath '/search/metadata' -ImmichSession:$Session -Body $Body | Select-Object -ExpandProperty assets
        $Result | Select-Object -ExpandProperty items | AddCustomType IMAsset
    }

}
#endregion
#EndRegion './Public/Search/Find-IMAsset.ps1' 253
#Region './Public/Search/Find-IMCity.ps1' -1

function Find-IMCity
{
    <#
    .DESCRIPTION
        Find cities
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Find-IMCity

        Retreives all cities
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method GET -RelativePath '/search/cities' -ImmichSession:$Session -Body $Body

}
#endregion
#EndRegion './Public/Search/Find-IMCity.ps1' 26
#Region './Public/Search/Find-IMExploreData.ps1' -1

function Find-IMExploreData
{
    <#
    .DESCRIPTION
        Find explore data
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Find-IMExploreData

        Retreives explore data
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method GET -RelativePath '/search/explore' -ImmichSession:$Session -Body $Body

}
#endregion
#EndRegion './Public/Search/Find-IMExploreData.ps1' 26
#Region './Public/Search/Find-IMPerson.ps1' -1

function Find-IMPerson
{
    <#
    .DESCRIPTION
        Find people
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Name
        Name filter
    .PARAMETER withHidden
        Filter hidden
    .EXAMPLE
        Find-IMPerson -name 'Jim Carrey'

        Search for persons named Jim Carrey
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]$Session = $null,

        [Parameter(Mandatory)]
        [string]$name,

        [Parameter()]
        [boolean]$withHidden
    )

    $Query = @{}
    $Query += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'name', 'withHidden')

    InvokeImmichRestMethod -Method GET -RelativePath '/search/person' -ImmichSession:$Session -QueryParameters:$Query

}
#endregion
#EndRegion './Public/Search/Find-IMPerson.ps1' 39
#Region './Public/Search/Find-IMPlace.ps1' -1

function Find-IMPlace
{
    <#
    .DESCRIPTION
        Find places
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Name
        Name filter
    .EXAMPLE
        Find-IMPlace -name 'Stockholm'

        Search for places named Stockholm
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]$Session = $null,

        [Parameter(Mandatory)]
        [string]$name
    )

    $Query = @{}
    $Query += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'name')

    InvokeImmichRestMethod -Method GET -RelativePath '/search/places' -ImmichSession:$Session -QueryParameters:$Query | AddCustomType IMPlace

}
#endregion
#EndRegion './Public/Search/Find-IMPlace.ps1' 34
#Region './Public/Server/Get-IMServer.ps1' -1

function Get-IMServer
{
    <#
    .DESCRIPTION
        Retreives all Immich server info properties
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServer

        Retreives all Immich server info properties
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    $ResultObject = [ordered]@{}
    $Results = [array]@()
    $Results += Get-IMServerAbout -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'About' -PassThru
    $Results += Get-IMServerConfig -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Config' -PassThru
    $Results += Get-IMServerFeature -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Feature' -PassThru
    $Results += Get-IMServerStatistic -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Stats' -PassThru
    $Results += Get-IMServerStorage -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Storage' -PassThru
    $Results += Get-IMServerVersion -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Version' -PassThru
    $Results += Get-IMSupportedMediaType -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Media' -PassThru
    $Results += Get-IMTheme -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Theme' -PassThru
    $Results += Test-IMPing -Session:$Session | Add-Member -MemberType NoteProperty -Name 'ObjectType' -Value 'Ping' -PassThru

    foreach ($Result in $Results)
    {
        foreach ($property in ($Result.PSObject.Properties.Name | Sort-Object))
        {
            if ($property -eq 'ObjectType')
            {
                continue
            }
            $ResultObject.Add("$($Result.ObjectType)_$Property", $Result.$Property)
        }
    }
    return [pscustomobject]$ResultObject

}
#endregion
#EndRegion './Public/Server/Get-IMServer.ps1' 48
#Region './Public/Server/Get-IMServerAbout.ps1' -1

function Get-IMServerAbout
{
    <#
    .DESCRIPTION
        Retreives Immich server about
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServerAbout

        Retreives Immich server about
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/server/about' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMServerAbout.ps1' 25
#Region './Public/Server/Get-IMServerConfig.ps1' -1

function Get-IMServerConfig
{
    <#
    .DESCRIPTION
        Retreives Immich server config
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServerConfig

        Retreives Immich server config
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -noauth -Method Get -RelativePath '/server/config' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMServerConfig.ps1' 25
#Region './Public/Server/Get-IMServerFeature.ps1' -1

function Get-IMServerFeature
{
    <#
    .DESCRIPTION
        Retreives Immich server feature
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServerFeature

        Retreives Immich server feature
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -noauth -Method Get -RelativePath '/server/features' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMServerFeature.ps1' 25
#Region './Public/Server/Get-IMServerLicense.ps1' -1

function Get-IMServerLicense
{
    <#
    .DESCRIPTION
        Retreives Immich server license
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServerLicense

        Retreives Immich server license
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath "/server/license" -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMServerLicense.ps1' 27
#Region './Public/Server/Get-IMServerStatistic.ps1' -1

function Get-IMServerStatistic
{
    <#
    .DESCRIPTION
        Retreives Immich server statistic
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServerStatistic

        Retreives Immich server statistic
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/server/statistics' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMServerStatistic.ps1' 25
#Region './Public/Server/Get-IMServerStorage.ps1' -1

function Get-IMServerStorage
{
    <#
    .DESCRIPTION
        Retreives Immich server config
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMServerConfig

        Retreives Immich server config
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/server/storage' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMServerStorage.ps1' 25
#Region './Public/Server/Get-IMServerVersion.ps1' -1

function Get-IMServerVersion
{
    <#
    .DESCRIPTION
        Retreives Immich server version
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER History
        Defines that version history should be return instead of the current version
    .EXAMPLE
        Get-IMServerVersion

        Retreives Immich server version
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null,

        [Parameter()][switch]$History
    )

    if ($History) {
        $Result = InvokeImmichRestMethod -noauth -Method Get -RelativePath '/server/version-history' -ImmichSession:$Session
        return $Result
    }
    else {
        $Result = InvokeImmichRestMethod -noauth -Method Get -RelativePath '/server/version' -ImmichSession:$Session
        return [pscustomobject]@{
            version = "$($Result.Major).$($Result.Minor).$($Result.Patch)"
        }
    }

}
#endregion
#EndRegion './Public/Server/Get-IMServerVersion.ps1' 38
#Region './Public/Server/Get-IMSupportedMediaType.ps1' -1

function Get-IMSupportedMediaType
{
    <#
    .DESCRIPTION
        Retreives Immich supported media type
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMSupportedMediaType

        Retreives Immich supported media type
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -noauth -Method Get -RelativePath '/server/media-types' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMSupportedMediaType.ps1' 25
#Region './Public/Server/Get-IMTheme.ps1' -1

function Get-IMTheme
{
    <#
    .DESCRIPTION
        Retreives Immich theme CSS
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-IMTheme

        Retreives Immich theme CSS
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method Get -RelativePath '/server/theme' -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Server/Get-IMTheme.ps1' 25
#Region './Public/Server/Remove-IMServerLicense.ps1' -1

function Remove-IMServerLicense
{
    <#
    .DESCRIPTION
        Removes Immich server license
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Remove-IMServerLicense

        Removes Immich server license
    #>

    [CmdletBinding(SupportsShouldProcess,DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    if ($PSCmdlet.ShouldProcess('Service license', 'remove')) {
        InvokeImmichRestMethod -Method Delete -RelativePath "/server/license" -ImmichSession:$Session
    }

}
#endregion
#EndRegion './Public/Server/Remove-IMServerLicense.ps1' 29
#Region './Public/Server/Set-IMServerLicense.ps1' -1

function Set-IMServerLicense
{
    <#
    .DESCRIPTION
        Sets Immich server license
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER ActivationKey
        Defines the activation key
    .PARAMETER LicenseKey
        Defines the license key
    .EXAMPLE
        Set-IMServerLicense -LicenseKey "ABC" -ActivationKey "ABC"

        Sets Immich server license
    #>

    [CmdletBinding(SupportsShouldProcess,DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    $BodyParameters = @{}
    $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'ActivationKey', 'LicenseKey' -namemapping @{ActivationKey = 'activationKey'; LicenseKey = 'licenseKey'} )

    if ($PSCmdlet.ShouldProcess('Service license', 'set')) {
        InvokeImmichRestMethod -Method Put -RelativePath "/server/license" -ImmichSession:$Session -Body:$BodyParameters
    }

}
#endregion
#EndRegion './Public/Server/Set-IMServerLicense.ps1' 36
#Region './Public/Server/Test-IMPing.ps1' -1

function Test-IMPing
{
    <#
    .DESCRIPTION
        Ping Immich instance
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Test-IMPing

        Ping Immich instance
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    $Result = InvokeImmichRestMethod -noauth -Method Get -RelativePath '/server/ping' -ImmichSession:$Session
    if ($Result.res -eq 'pong')
    {
        return [pscustomobject]@{responds = $true }
    }
    else
    {
        return [pscustomobject]@{responds = $false }
    }

}
#endregion
#EndRegion './Public/Server/Test-IMPing.ps1' 33
#Region './Public/ServerConfig/Get-IMConfig.ps1' -1

function Get-IMConfig
{
    <#
    .DESCRIPTION
        Retreives Immich config
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Default
        Retreives default config instead of current applied
    .PARAMETER ReturnRawJSON
        This is useful if you want to alter the current config and pass it on to Set-IMConfig
    .PARAMETER StorageTemplate
        Specifies that storage template configuration should be returned.
    .EXAMPLE
        Get-IMConfig

        Retreives Immich config
    #>

    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'applied')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(ParameterSetName = 'applied')]
        [Parameter(ParameterSetName = 'default')]
        [switch]
        $ReturnRawJSON,

        [Parameter(ParameterSetName = 'default')]
        [switch]
        $Default,

        [Parameter(ParameterSetName = 'storage')]
        [switch]
        $StorageTemplate

    )

    switch ($PSCmdlet.ParameterSetName)
    {
        'applied'
        {
            $Result = InvokeImmichRestMethod -Method Get -RelativePath '/system-config' -ImmichSession:$Session
            if ($ReturnRawJSON)
            {
                $Result | ConvertTo-Json -Depth 10
            }
            else
            {
                $Result
            }
            break
        }
        'default'
        {
            $Result = InvokeImmichRestMethod -Method Get -RelativePath '/system-config/defaults' -ImmichSession:$Session
            if ($ReturnRawJSON)
            {
                $Result | ConvertTo-Json -Depth 10
            }
            else
            {
                $Result
            }
            break
        }
        'storage'
        {
            InvokeImmichRestMethod -Method Get -RelativePath '/system-config/storage-template-options' -ImmichSession:$Session
            break
        }
    }

}
#endregion
#EndRegion './Public/ServerConfig/Get-IMConfig.ps1' 81
#Region './Public/ServerConfig/Set-IMConfig.ps1' -1

function Set-IMConfig
{
    <#
    .DESCRIPTION
        Set immich config
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER RawJSON
        Defines the immich configuration. Provided as JSON text.
    .EXAMPLE
        Set-IMConfig

        Set immich config
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [string]
        $RawJSON
    )

    if ($PSCmdlet.ShouldProcess('Config', 'Set'))
    {
        InvokeImmichRestMethod -Method Put -RelativePath '/system-config' -ImmichSession:$Session -RawBody:$RawJSON
    }
}
#endregion
#EndRegion './Public/ServerConfig/Set-IMConfig.ps1' 35
#Region './Public/Session/Connect-Immich.ps1' -1

function Connect-Immich
{
    <#
    .DESCRIPTION
        Connect to a Immich instance
    .PARAMETER BaseURL
        Defines the base URL to the immich instance

        -BaseURL 'https://immich.domain.com'
    .PARAMETER AccessToken
        Connects to immich using a access token. This AccessToken can be generated from the Immich Web GUI.

        -AccessToken 'ABoR54bB1NUc4aNY0F2PhppP1tVDu2Husr3vEbPUsw5'
    .PARAMETER Credential
        Connect to immich using username and password. Parameter accepts a PSCredentials object

        -Credential (Get-Credential)
    .PARAMETER PassThru
        This parameter will cause the function to return a ImmichSession object that can be stored in a variable and referensed with the -Session parameter on most cmdlets.

        -PassThru
    .EXAMPLE
        Connect-Immich -BaseURL 'https://immich.domain.com' -AccessToken 'ABoR54bB1NUc4aNY0F2PhppP1tVDu2Husr3vEbPUsw5'

        Connect using access token
    .EXAMPLE
        Connect-Immich -BaseURL 'https://immich.domain.com' -Credentials (Get-Credential)

        Connect using username and password
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSAvoidUsingConvertToSecureStringWithPlainText', '', Justification = 'AccessToken')]

    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][string]$BaseURL,
        [Parameter(ParameterSetName = 'AccessToken')][string]$AccessToken,
        [Parameter(ParameterSetName = 'Credentials')][pscredential]$Credential,
        [switch]$PassThru
    )

    switch ($PSCmdlet.ParameterSetName)
    {
        'AccessToken'
        {
            $AccessTokenSS = ConvertTo-SecureString -String $AccessToken -AsPlainText -Force
            Remove-Variable -Name AccessToken
            $script:ImmichSession = [ImmichSession]::New($BaseURL, $AccessTokenSS)
        }
        'Credentials'
        {
            $script:ImmichSession = [ImmichSession]::New($BaseURL, $Credential)
        }
    }

    if ($Passthru)
    {
        return $script:ImmichSession
    }
}
#EndRegion './Public/Session/Connect-Immich.ps1' 60
#Region './Public/Session/Disconnect-Immich.ps1' -1

function Disconnect-Immich
{
    <#
    .DESCRIPTION
        Disconnect and cleanup session configuration
    .PARAMETER Session
        Defines a ImmichSession object that will be disconnected and cleaned up.
    .EXAMPLE
        Disconnect-Immich

        Disconnect from the default immich session
    .EXAMPLE
        Disconnect-Immich -Session $Session

        Disconnect the specified session
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    InvokeImmichRestMethod -Method Post -RelativePath '/auth/logout' -ImmichSession:$Session

    # Remove ImmichSession variable
    if ($Session)
    {
        if ($script:ImmichSession.SessionID -eq $Session.SessionID)
        {
            Remove-Variable ImmichSession -Scope Script
        }
    }
    else
    {
        Remove-Variable ImmichSession -Scope Script
    }

}
#EndRegion './Public/Session/Disconnect-Immich.ps1' 39
#Region './Public/Session/Get-IMSession.ps1' -1

function Get-IMSession
{
    <#
    .DESCRIPTION
        Displays the Immich Session object.
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Get-PSession

        Returns the ImmichSession, if none is specified, it tries to retreive the default
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null
    )

    if ($Session)
    {
        Write-Debug -Message 'Get-PSession; ImmichSession was passed as parameter'
        return $Session
    }
    elseif ($script:ImmichSession)
    {
        Write-Debug -Message 'Get-PSession; ImmichSession found in script scope'
        return $script:ImmichSession
    }
    else
    {
        Write-Error -Message 'No Immich Session established, please call Connect-Immich'
    }
}
#endregion
#EndRegion './Public/Session/Get-IMSession.ps1' 37
#Region './Public/Session/Invoke-ImmichMethod.ps1' -1

function Invoke-ImmichMethod
{
    <#
    .DESCRIPTION
        Invokes command
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Headers
        Headers
    .PARAMETER QueryParameters
        Query parameters
    .PARAMETER BodyParameters
        Body parameters
    .PARAMETER Method
        Method
    .PARAMETER RelativeURI
        RelativePath
    .PARAMETER ContentType
        ContentType
    .PARAMETER OutFilePath
        OutFilePath
    .EXAMPLE
        Invoke-ImmichMethod

        Retreives all Immich server info properties
    #>

    [CmdletBinding()]
    param(
        [Parameter()][ImmichSession]$Session = $null,

        [Parameter()][hashtable]$Headers,

        [Parameter()][hashtable]$QueryParameters,

        [Parameter()][hashtable]$BodyParameters,

        [Parameter()][string]$Method,

        [Parameter()][string]$RelativeURI,

        [Parameter()][string]$ContentType = 'application/json',

        [Parameter()][system.io.fileinfo]$OutFilePath
    )

    $Parameters = @{
        Method       = $Method
        RelativePath = $RelativeURI
        ContentType  = $ContentType
    }

    if ($QueryParameters)
    {
        $Parameters.QueryParameters = $QueryParameters
    }

    if ($BodyParameters)
    {
        $Parameters.Body = $BodyParameters
    }
    if ($Headers)
    {
        $Parameters.Headers = $Headers
    }
    if ($OutFilePath)
    {
        $Parameters.OutFilePath = $OutFilePath
    }

    InvokeImmichRestMethod @Parameters -ImmichSession:$Session

}
#endregion
#EndRegion './Public/Session/Invoke-ImmichMethod.ps1' 77
#Region './Public/SharedLink/Add-IMSharedLinkAsset.ps1' -1

function Add-IMSharedLinkAsset
{
    <#
    .DESCRIPTION
        Add Immich shared link asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines assets to add to the shared link
    .PARAMETER SharedLinkId
        Defines a shared link to add assets to
    .EXAMPLE
        Add-IMSharedLinkAsset

        Add Immich shared link asset
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $Id,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $SharedLinkId
    )

    BEGIN
    {
        $AssetIDs = [System.Collections.Generic.List[string]]::New()
    }

    PROCESS
    {
        $id | ForEach-Object {
            $AssetIDs.Add($PSItem)
        }
    }

    END
    {
        $Body = @{
            assetIds = $AssetIDs
        }
        InvokeImmichRestMethod -Method PUT -RelativePath "/shared-links/$SharedLinkId/assets" -ImmichSession:$Session -Body $Body
    }
}
#endregion
#EndRegion './Public/SharedLink/Add-IMSharedLinkAsset.ps1' 58
#Region './Public/SharedLink/Get-IMSharedLink.ps1' -1

function Get-IMSharedLink
{
    <#
    .DESCRIPTION
        Retreives Immich shared link
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific shared link id to be retreived
    .PARAMETER password
        ...
    .PARAMETER token
        ...
    .PARAMETER Me
        Defines that the currently connected users information is retreived.
    .EXAMPLE
        Get-IMSharedLink

        Retreives Immich shared link
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter(ParameterSetName = 'me')]
        [securestring]
        $password,

        [Parameter(ParameterSetName = 'me')]
        [string]
        $token,

        [Parameter(Mandatory, ParameterSetName = 'me')]
        [switch]
        $Me
    )

    BEGIN
    {
        if ($PSCmdlet.ParameterSetName -eq 'list')
        {
            $QueryParameters = @{}
            $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'password', 'token')
        }
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'list'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/shared-links' -ImmichSession:$Session -QueryParameters $QueryParameters
            }
            'id'
            {
                $id | ForEach-Object {
                    InvokeImmichRestMethod -Method Get -RelativePath "/shared-links/$PSItem" -ImmichSession:$Session
                }
            }
            'me'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/shared-links/me' -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/SharedLink/Get-IMSharedLink.ps1' 79
#Region './Public/SharedLink/New-IMSharedLink.ps1' -1

function New-IMSharedLink
{
    <#
    .DESCRIPTION
        New Immich shared link
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER AssetId
        Defines the asset ids to share
    .PARAMETER AlbumId
        Defines the albumid to share
    .PARAMETER AllowDownload
        Defines if downloading of assets are permitted.
    .PARAMETER AllowUpload
        Defines if uploads of assets are permitted.
    .PARAMETER Description
        Defines a description of the shared link
    .PARAMETER ExpiresAt
        Defines an expiration date of the shared link
    .PARAMETER ShowMetadata
        Defines if asset metadata is shown
    .PARAMETER Password
        Defines a password for the shared link
    .EXAMPLE
        New-IMSharedLink

        New Immich shared link
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'FP')]
    [CmdletBinding(DefaultParameterSetName = 'asset')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'asset', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $AssetId,

        [Parameter(Mandatory, ParameterSetName = 'album')]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $AlbumId,

        [Parameter()]
        [switch]
        $AllowDownload,

        [Parameter()]
        [switch]
        $AllowUpload,

        [Parameter()]
        [string]
        $Description,

        [Parameter()]
        [datetime]
        $ExpiresAt,

        [Parameter()]
        [switch]
        $ShowMetadata,

        [Parameter()]
        [securestring]
        $Password
    )

    BEGIN
    {
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'AllowDownload', 'AllowUpload', 'Description', 'ExpiresAt', 'ShowMetadata', 'Password' -NameMapping @{
                AllowDownload = 'allowDownload'
                AllowUpload   = 'allowUpload'
                Description   = 'description'
                ExpiresAt     = 'expiresAt'
                ShowMetadata  = 'showMetadata'
                Password      = 'password'
            })
        if ($PSCmdlet.ParameterSetName -eq 'asset')
        {
            $Body.assetIds = [string[]]@()
            $Body.type = 'INDIVIDUAL'
        }
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'asset'
            {
                $AssetId | ForEach-Object {
                    $Body.assetIds += $PSItem
                }
            }
            'album'
            {
                $Body += @{
                    type    = 'ALBUM'
                    albumId = $AlbumId
                }
            }
        }
    }

    END
    {
        InvokeImmichRestMethod -Method POST -RelativePath '/shared-links' -ImmichSession:$Session -Body $Body
    }
}
#endregion
#EndRegion './Public/SharedLink/New-IMSharedLink.ps1' 117
#Region './Public/SharedLink/Remove-IMSharedLink.ps1' -1

function Remove-IMSharedLink
{
    <#
    .DESCRIPTION
        Remove Immich shared link
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific shared link id to be removed
    .EXAMPLE
        Remove-IMSharedLink -id <sharedlinkid>

        Remove Immich shared link
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'DELETE'))
            {
                InvokeImmichRestMethod -Method DELETE -RelativePath "/shared-links/$PSItem" -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/SharedLink/Remove-IMSharedLink.ps1' 41
#Region './Public/SharedLink/Remove-IMSharedLinkAsset.ps1' -1

function Remove-IMSharedLinkAsset
{
    <#
    .DESCRIPTION
        Remove Immich shared link asset
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines assets to add to the shared link
    .PARAMETER SharedLinkId
        Defines a shared link to add assets to
    .EXAMPLE
        Remove-IMSharedLinkAsset -id <assetid> -sharedlinkid <sharedlinkid>

        Remove Immich shared link asset
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $Id,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $SharedLinkId
    )

    BEGIN
    {
        $AssetIDs = [System.Collections.Generic.List[string]]::New()
    }

    PROCESS
    {
        $id | ForEach-Object {
            $AssetIDs.Add($PSItem)
        }
    }

    END
    {
        $Body = @{
            assetIds = $AssetIDs
        }
        InvokeImmichRestMethod -Method DELETE -RelativePath "/shared-links/$SharedLinkId/assets" -ImmichSession:$Session -Body $Body
    }
}
#endregion
#EndRegion './Public/SharedLink/Remove-IMSharedLinkAsset.ps1' 58
#Region './Public/SharedLink/Set-IMSharedLink.ps1' -1

function Set-IMSharedLink
{
    <#
    .DESCRIPTION
        Set Immich shared link
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER Id
        Defines the asset ids to share
    .PARAMETER AllowDownload
        Defines if downloading of assets are permitted.
    .PARAMETER AllowUpload
        Defines if uploads of assets are permitted.
    .PARAMETER Description
        Defines a description of the shared link
    .PARAMETER ExpiresAt
        Defines an expiration date of the shared link
    .PARAMETER ShowMetadata
        Defines if asset metadata is shown
    .PARAMETER Password
        Defines a password for the shared link
    .EXAMPLE
        Set-IMSharedLink -id <sharedlinkid> -AllowDownload

        Set Immich shared link
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $Id,

        [Parameter()]
        [switch]
        $AllowDownload,

        [Parameter()]
        [switch]
        $AllowUpload,

        [Parameter()]
        [string]
        $Description,

        [Parameter()]
        [datetime]
        $ExpiresAt,

        [Parameter()]
        [switch]
        $ShowMetadata,

        [Parameter()]
        [securestring]
        $Password
    )

    BEGIN
    {
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'AllowDownload', 'AllowUpload', 'Description', 'ExpiresAt', 'ShowMetadata', 'Password' -NameMapping @{
                AllowDownload = 'allowDownload'
                AllowUpload   = 'allowUpload'
                Description   = 'description'
                ExpiresAt     = 'expiresAt'
                ShowMetadata  = 'showMetadata'
                Password      = 'password'
            })
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'Update'))
            {
                InvokeImmichRestMethod -Method PATCH -RelativePath "/shared-links/$PSItem" -ImmichSession:$Session -Body $Body
            }
        }
    }

}
#endregion
#EndRegion './Public/SharedLink/Set-IMSharedLink.ps1' 91
#Region './Public/Tag/Get-IMTag.ps1' -1

function Get-IMTag
{
    <#
    .DESCRIPTION
        Retreives Immich tag
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific tag id to be retreived
    .EXAMPLE
        Get-IMTag

        Retreives Immich tag
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        if ($PSCmdlet.ParameterSetName -eq 'id')
        {
            $id | ForEach-Object {
                $CurrentID = $PSItem
                InvokeImmichRestMethod -Method Get -RelativePath "/tags/$CurrentID" -ImmichSession:$Session
            }
        }
    }

    END
    {
        if ($PSCmdlet.ParameterSetName -eq 'list')
        {
            InvokeImmichRestMethod -Method Get -RelativePath '/tags' -ImmichSession:$Session
        }
    }
}
#endregion
#EndRegion './Public/Tag/Get-IMTag.ps1' 50
#Region './Public/Tag/New-IMTag.ps1' -1

function New-IMTag
{
    <#
    .DESCRIPTION
        Creates a new Immich tag
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER name
        Defines a name for the new tag
    .PARAMETER type
        Defines the type of tag to create. Valid values, OBJECT, FACE, CUSTOM
    .EXAMPLE
        New-IMTag -name 'Dogs' -type OBJECT

        Creates a new Immich tag
    #>

    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string]
        $name,

        [Parameter(Mandatory)]
        [string]
        $type
    )

    $BodyParameters = @{}
    $BodyParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'name', 'type')
    InvokeImmichRestMethod -Method Post -RelativePath '/tags' -ImmichSession:$Session -Body:$BodyParameters

}
#endregion
#EndRegion './Public/Tag/New-IMTag.ps1' 42
#Region './Public/Tag/Remove-IMTag.ps1' -1

function Remove-IMTag
{
    <#
    .DESCRIPTION
        Remove Immich tag
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific tag id to be retreived
    .EXAMPLE
        Remove-IMTag -id <tagid>

        Remove Immich tag
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            if ($PSCmdlet.ShouldProcess($CurrentID, 'Remove'))
            {
                InvokeImmichRestMethod -Method DELETE -RelativePath "/tags/$CurrentID" -ImmichSession:$Session
            }
        }
    }
}
#endregion
#EndRegion './Public/Tag/Remove-IMTag.ps1' 42
#Region './Public/Tag/Set-IMTag.ps1' -1

function Set-IMTag
{
    <#
    .DESCRIPTION
        Add Immich asset tag
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines an asset id to tag
    .PARAMETER tagId
        Defines a tag id to assign to assets
    .PARAMETER tagName
        Defines a tag name to assign to assets. Note that the Immich API does support filtering on tagName so all tags will be retreived and then filtered. This means that if there is a very large amount of tags this method might be slow.
    .PARAMETER AddAssets
        Defines the assets to tag
    .PARAMETER RemoveAssets
        Defines the assets to untag
    .PARAMETER Color
        Defines the tag color, acceppts a HEX string ie, #000000
    .EXAMPLE
        Set-IMTag -AddAssets <assetid>

        Add tag to asset
    #>

    [CmdletBinding(SupportsShouldProcess, DefaultParameterSetName = 'tagId')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'tagid', ValueFromPipeline, ValueFromPipelineByPropertyName)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $Id,

        [Parameter(Mandatory, ParameterSetName = 'tagName')]
        [string]
        $tagName,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $AddAssets,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $RemoveAssets,

        [Parameter()]
        [string]
        $Color
    )

    BEGIN
    {
        if ($PSCmdlet.ParameterSetName -eq 'tagName')
        {
            $TagObject = Get-IMTag | Where-Object { $_.name -eq $tagName }
            if ($TagObject)
            {
                $id = $TagObject.id
            }
            else
            {
                throw "Unable to find tag with name $($tagName)"
            }
        }
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($id, 'Update tag'))
            {
                if ($PSBoundParameters.Keys -contains 'AddAssets') {
                    InvokeImmichRestMethod -Method PUT -RelativePath "/tags/$PSitem/assets" -ImmichSession:$Session -Body:@{ids = ($AddAssets -as [string[]])}
                }
                if ($PSBoundParameters.Keys -contains 'RemoveAssets') {
                    InvokeImmichRestMethod -Method DELETE -RelativePath "/tags/$PSitem/assets" -ImmichSession:$Session -Body:@{ids = ($RemoveAssets -as [string[]])}
                }
                if ($PSBoundParameters.Keys -contains 'Color') {
                    InvokeImmichRestMethod -Method PUT -RelativePath "/tags/$PSitem" -ImmichSession:$Session -Body:@{color = $Color}
                }
            }
        }
    }
}
#endregion
#EndRegion './Public/Tag/Set-IMTag.ps1' 93
#Region './Public/Timeline/Get-IMTimeBucket.ps1' -1

function Get-IMTimeBucket
{
    <#
    .DESCRIPTION
        Retreives timebucket objects
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER albumId
        Albumid filter
    .PARAMETER isArchived
        Archived filter
    .PARAMETER isFavorite
        Favorite filter
    .PARAMETER isTrashed
        Trashed filter
    .PARAMETER order
        Defines sort order
    .PARAMETER personId
        PersonId filter
    .PARAMETER size
        Defines size, DAY or MONTH
    .PARAMETER timeBucket
        Timebucket
    .PARAMETER userId
        UserId filter
    .PARAMETER withPartners
        With partners filter
    .PARAMETER withStacked
        With stacked filter
    .EXAMPLE
        Get-IMTimeBucket

        Retreives timebucket
    #>

    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $albumId,

        [Parameter()]
        [boolean]
        $isArchived,

        [Parameter()]
        [boolean]
        $isFavorite,

        [Parameter()]
        [boolean]
        $isTrashed,

        [Parameter()]
        [ValidateSet('asc', 'desc')]
        [string]
        $order = 'asc',

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $personId,

        [Parameter(Mandatory)]
        [ValidateSet('DAY', 'MONTH')]
        [string]
        $size,

        [Parameter(ParameterSetName = 'timebucket')]
        [string]
        $timeBucket,

        [Parameter()]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $userId,

        [Parameter()]
        [boolean]
        $withPartners,

        [Parameter()]
        [boolean]
        $withStacked
    )

    BEGIN
    {
        $QueryParameters = @{}
        $QueryParameters += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'albumId', 'isArchived', 'isFavorite', 'isTrashed', 'order', 'personId', 'size', 'timeBucket', 'userId', 'withPartners', 'withStacked')
    }

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'list'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/timeline/buckets' -ImmichSession:$Session -QueryParameters $QueryParameters
            }
            'timebucket'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/timeline/bucket' -ImmichSession:$Session -QueryParameters $QueryParameters
            }
        }
    }
}
#endregion
#EndRegion './Public/Timeline/Get-IMTimeBucket.ps1' 116
#Region './Public/User/Add-IMMyProfilePicture.ps1' -1

function Add-IMMyProfilePicture
{
    <#
    .DESCRIPTION
        Adds an Immich user profile picture
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER FilePath
        Defines the asset ids that should be removed. Accepts pipeline input.
    .EXAMPLE
        Add-IMMyProfilePicture -FilePath C:\avatar.jpg

        Add profile picture to current user
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP, retreived through PSBoundParameters')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [System.IO.FileInfo]
        $FilePath
    )

    BEGIN
    {
        # Do not run on Windows Powershell
        if ($PSVersionTable.PSEdition -eq 'Desktop')
        {
            Write-Warning -Message 'Add-IMMyProfilePicture is not currently supported on Windows Powershell, please use Powershell Core on Windows instead.'
            break
        }
    }

    PROCESS
    {
            $FileInfo = Get-Item -Path $FilePath.FullName
            $Uri = "$($ImmichSession.ApiUri)/users/profile-image"
            $Header = @{
                'Accept'    = 'application/json'
                'x-api-key' = ConvertFromSecureString -SecureString $ImmichSession.AccessToken
            }
            $Form = @{}
            $Form += @{
                file      = $FileInfo
            }
            $Result = Invoke-WebRequest -Uri $Uri -Method Post -Headers $Header -Form $Form -ContentType 'multipart/form-data'
            $Result.Content | ConvertFrom-Json
    }
}
#EndRegion './Public/User/Add-IMMyProfilePicture.ps1' 55
#Region './Public/User/Export-IMProfilePicture.ps1' -1

function Export-IMProfilePicture
{
    <#
    .DESCRIPTION
        Export Immich profile picture
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the user id to retreive the profile picture for
    .PARAMETER Path
        Defines the directory for the output file
    .EXAMPLE
        Export-IMProfilePicture -id <personid> -Path C:\download

        Export user profile picture
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string]
        $id,

        [Parameter()]
        [System.IO.DirectoryInfo]
        $Path
    )

    PROCESS
    {
        $id | ForEach-Object {
            $CurrentID = $PSItem
            $OutputPath = Join-Path -Path $Path -ChildPath "$($CurrentID).jpeg"
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $SavedProgressPreference = $global:ProgressPreference
                $global:ProgressPreference = 'SilentlyContinue'
            }
            InvokeImmichRestMethod -Method Get -RelativePath "/users/$CurrentID/profile-image" -ImmichSession:$Session -ContentType 'application/octet-stream' -OutFilePath $OutputPath
            if ($PSVersionTable.PSEdition -eq 'Desktop')
            {
                $global:ProgressPreference = $SavedProgressPreference
            }
        }
    }

}
#endregion
#EndRegion './Public/User/Export-IMProfilePicture.ps1' 56
#Region './Public/User/Get-IMUser.ps1' -1

function Get-IMUser
{
    <#
    .DESCRIPTION
        Retreives Immich user
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific user id to be retreived
    .PARAMETER IncludeDeleted
        Defines if deleted users should be returned.
    .PARAMETER Me
        Defines that the currently connected users information is retreived.
    .EXAMPLE
        Get-IMUser -id <userid>

        Retreives Immich user
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP, evaluated as part of parameterset check')]
    [CmdletBinding(DefaultParameterSetName = 'list')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter(ParameterSetName = 'list')]
        [switch]
        $IncludeDeleted,

        [Parameter(Mandatory, ParameterSetName = 'me')]
        [switch]
        $Me
    )

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'list'
            {
                if ($IncludeDeleted)
                {
                    InvokeImmichRestMethod -Method Get -RelativePath '/admin/users' -ImmichSession:$Session -Query:@{withDeleted = $true } | AddCustomType IMUser
                }
                else
                {
                    InvokeImmichRestMethod -Method Get -RelativePath '/admin/users' -ImmichSession:$Session | AddCustomType IMUser
                }
            }
            'id'
            {
                $id | ForEach-Object {
                    InvokeImmichRestMethod -Method Get -RelativePath "/admin/users/$PSItem" -ImmichSession:$Session | AddCustomType IMUser
                }
            }
            'me'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/users/me' -ImmichSession:$Session | AddCustomType IMUser
            }
        }
    }
}
#endregion
#EndRegion './Public/User/Get-IMUser.ps1' 71
#Region './Public/User/Get-IMUserPreference.ps1' -1

function Get-IMUserPreference
{
    <#
    .DESCRIPTION
        Retreives Immich user preference
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines a specific user id to be retreived
    .EXAMPLE
        Get-IMUserPreference -id <userid>

        Retreives Immich user preferences
    .EXAMPLE
        Get-IMUserPreference

        Retrevies Immich user preferences for the currently logged in user
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Justification = 'FP, evaluated as part of parameterset check')]
    [CmdletBinding(DefaultParameterSetName = 'me')]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ParameterSetName = 'id', ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )

    PROCESS
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'id'
            {
                $id | ForEach-Object {
                    InvokeImmichRestMethod -Method Get -RelativePath "/admin/users/$PSItem/preferences" -ImmichSession:$Session | AddCustomType IMUserPreference
                }
            }
            'me'
            {
                InvokeImmichRestMethod -Method Get -RelativePath '/users/me/preferences' -ImmichSession:$Session | AddCustomType IMUserPreference
            }
        }
    }
}
#endregion
#EndRegion './Public/User/Get-IMUserPreference.ps1' 52
#Region './Public/User/New-IMUser.ps1' -1

function New-IMUser
{
    <#
    .DESCRIPTION
        New Immich user
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER email
        Defines a specific user id to be retreived
    .PARAMETER Notify
        Should the user be notified. Enabled by default
    .PARAMETER Name
        Defines the name of the user
    .PARAMETER Password
        Defines the password for the user
    .PARAMETER QuotaSizeInBytes
        Defines quota for the user
    .PARAMETER ShouldChangePassword
        Defines that the user must change password on the next login
    .PARAMETER StorageLabel
        Defines the users storage label
    .EXAMPLE
        $Password = Read-Host -Prompt 'Password' -AsSecureString
        New-IMUser -Email 'testuser@domain.com' -Name 'Test User' -Password $Password

        Creates new Immich user
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions','', Justification='FP')]
    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory)]
        [string]
        $Email,

        [Parameter()]
        [boolean]
        $Notify = $true,

        [Parameter(Mandatory)]
        [string]
        $Name,

        [Parameter(Mandatory)]
        [securestring]
        $Password,

        [Parameter()]
        [int64]
        $QuotaSizeInBytes,

        [Parameter()]
        [boolean]
        $ShouldChangePassword,

        [Parameter()]
        [string]
        $StorageLabel
    )

    $Body = @{}
    $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Email', 'Notify', 'Name', 'Password', 'QuotaSizeInBytes', 'ShouldChangePassword', 'StorageLabel' -NameMapping @{
            Email                = 'email'
            Notify               = 'notify'
            Name                 = 'name'
            Password             = 'password'
            QuotaSizeInBytes     = 'quotaSizeInBytes'
            ShouldChangePassword = 'shouldChangePassword'
            StorageLabel         = 'storageLabel'
        })

    InvokeImmichRestMethod -Method POST -RelativePath '/admin/users' -ImmichSession:$Session -Body $Body

}
#endregion
#EndRegion './Public/User/New-IMUser.ps1' 81
#Region './Public/User/Remove-IMMyProfilePicture.ps1' -1

function Remove-IMMyProfilePicture
{
    <#
    .DESCRIPTION
        Remove the profile picture of the connected user
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .EXAMPLE
        Remove-IMMyProfilePicture

        Remove the profile picture of the connected user
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null
    )

    if ($PSCmdlet.ShouldProcess('Remove profile picture')) {
        InvokeImmichRestMethod -Method DELETE -RelativePath '/users/profile-image' -ImmichSession:$Session
    }

}
#endregion
#EndRegion './Public/User/Remove-IMMyProfilePicture.ps1' 29
#Region './Public/User/Remove-IMUser.ps1' -1

function Remove-IMUser
{
    <#
    .DESCRIPTION
        Remove Immich user
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the user id to update
    .PARAMETER force
        Defines that the user should be removed immediatly. By default the user remains in trash for 7 days before assets are removed.
    .EXAMPLE
        Remove-IMUser -id <userid> -force

        Remove Immich user
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [switch]
        $Force
    )

    BEGIN
    {
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Force' -NameMapping @{
                Force = 'force'
            })
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem, 'DELETE'))
            {
                InvokeImmichRestMethod -Method DELETE -RelativePath "/admin/users/$PSItem" -ImmichSession:$Session -Body $Body
            }
        }
    }

}
#endregion
#EndRegion './Public/User/Remove-IMUser.ps1' 56
#Region './Public/User/Restore-IMUser.ps1' -1

function Restore-IMUser
{
    <#
    .DESCRIPTION
        Restore Immich user
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the user id to update
    .EXAMPLE
        Restore-IMUser -id <userid>

        Restore Immich user
    #>

    [CmdletBinding()]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id
    )


    PROCESS
    {
        $id | ForEach-Object {
            InvokeImmichRestMethod -Method POST -RelativePath "/admin/users/$PSItem/restore" -ImmichSession:$Session
        }
    }

}
#endregion
#EndRegion './Public/User/Restore-IMUser.ps1' 40
#Region './Public/User/Set-IMUser.ps1' -1

function Set-IMUser
{
    <#
    .DESCRIPTION
        Set Immich user
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the user id to update
    .PARAMETER IsAdmin
        Defines if the user should be admin
    .PARAMETER AvatarColor
        Defines the avatar color for the user
    .PARAMETER email
        Defines a specific user id to be retreived
    .PARAMETER MemoriesEnabled
        Should Memories enabled. Enabled by default
    .PARAMETER Name
        Defines the name of the user
    .PARAMETER Password
        Defines the password for the user
    .PARAMETER QuotaSizeInBytes
        Defines quota for the user
    .PARAMETER ShouldChangePassword
        Defines that the user must change password on the next login
    .PARAMETER StorageLabel
        Defines the users storage label
    .EXAMPLE
        Set-IMUser -id <userid> -Name 'John Smith'

        Set Immich user
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [string]
        $Email,

        [Parameter()]
        [string]
        $Name,

        [Parameter()]
        [securestring]
        $Password,

        [Parameter()]
        [int64]
        $QuotaSizeInBytes,

        [Parameter()]
        [boolean]
        $ShouldChangePassword,

        [Parameter()]
        [string]
        $StorageLabel
    )

    BEGIN
    {
        $Body = @{}
        $Body += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'Email', 'Name', 'Password', 'QuotaSizeInBytes', 'ShouldChangePassword', 'StorageLabel' -NameMapping @{
                Email                = 'email'
                Name                 = 'name'
                Password             = 'password'
                QuotaSizeInBytes     = 'quotaSizeInBytes'
                ShouldChangePassword = 'shouldChangePassword'
                StorageLabel         = 'storageLabel'
            })
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem,'Set')) {
                InvokeImmichRestMethod -Method PUT -RelativePath "/admin/users/$PSItem" -ImmichSession:$Session -Body $Body
            }
        }
    }

}
#endregion
#EndRegion './Public/User/Set-IMUser.ps1' 96
#Region './Public/User/Set-IMUserPreference.ps1' -1

function Set-IMUserPreference
{
    <#
    .DESCRIPTION
        Set Immich user preference
    .PARAMETER Session
        Optionally define a immich session object to use. This is useful when you are connected to more than one immich instance.

        -Session $Session
    .PARAMETER id
        Defines the user id to update
    .PARAMETER AvatarColor
        Select the avatar color to use. Valid values are primary, pink, red, yellow, blue, green, purple, orange, gray, amber.
    .PARAMETER DownloadArchiveSize
        Not defines
    .PARAMETER EmailNotificationForAlbumInvite
        Select if an email notification should be sent to the user if an album is shared to the user.
    .PARAMETER EmailNotificationForAlbumUpdate
        Select if an email notification should be sent to the user if an album that is shared to the user is updated.
    .PARAMETER EmailNotificationEnabled
        Select if email notifications are enabled.
    .PARAMETER MemoriesEnabled
        Select if memories should be shown to the user
    .PARAMETER HideBuyButtonUntil
        Select if the Buy Immich button should be hidden for, accepts a datetime value.
    .PARAMETER ShowSupportBadge
        Select if the Support Immich badge should be shown.
    .EXAMPLE
        Set-IMUserPreference -id <userid> -AvatarColor green

        Set Immich user preferences
    #>

    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter()]
        [ImmichSession]
        $Session = $null,

        [Parameter(Mandatory, ValueFromPipelineByPropertyName, ValueFromPipeline)]
        [ValidatePattern('^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$')]
        [string[]]
        $id,

        [Parameter()]
        [ValidateSet('primary', 'pink', 'red', 'yellow', 'blue', 'green', 'purple', 'orange', 'gray', 'amber')]
        [string]
        $AvatarColor,

        [Parameter()]
        [int]
        $DownloadArchiveSize,

        [Parameter()]
        [boolean]
        $EmailNotificationForAlbumInvite,

        [Parameter()]
        [boolean]
        $EmailNotificationForAlbumUpdate,

        [Parameter()]
        [boolean]
        $EmailNotificationEnabled,

        [Parameter()]
        [boolean]
        $MemoriesEnabled,

        [Parameter()]
        [datetime]
        $HideBuyButtonUntil,

        [Parameter()]
        [boolean]
        $ShowSupportBadge
    )

    BEGIN
    {
        $Body = @{}
        $Body.avatar += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'AvatarColor' -NameMapping @{
                AvatarColor = 'color'
        })
        $Body.download += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'DownloadArchiveSize' -NameMapping @{
                DownloadArchiveSize = 'archiveSize'
        })
        $Body.emailNotifications += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'EmailNotificationForAlbumInvite','EmailNotificationForAlbumUpdate','EmailNotificationEnabled' -NameMapping @{
                EmailNotificationForAlbumInvite = 'albumInvite'
                EmailNotificationForAlbumUpdate = 'albumUpdate'
                EmailNotificationEnabled = 'enabled'
        })
        $Body.memories += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'MemoriesEnabled' -NameMapping @{
                MemoriesEnabled = 'enabled'
        })
        $Body.purchase += (SelectBinding -Binding $PSBoundParameters -SelectProperty 'HideBuyButtonUntil','ShowSupportBadge' -NameMapping @{
                HideBuyButtonUntil = 'hideBuyButtonUntil'
                ShowSupportBadge = 'showSupportBadge'
        })

        # The above body keys are added regardless of if they are actually populated. Therefor remove empty ones.
        $Body.Clone().Keys | foreach-object {if ($Body.$PSItem.Count -eq 0) {$Body.Remove($PSItem)}}
    }

    PROCESS
    {
        $id | ForEach-Object {
            if ($PSCmdlet.ShouldProcess($PSItem,'Set')) {
                InvokeImmichRestMethod -Method PUT -RelativePath "/admin/users/$PSItem/preferences" -ImmichSession:$Session -Body $Body
            }
        }
    }

}
#endregion
#EndRegion './Public/User/Set-IMUserPreference.ps1' 116
#Region './suffix.ps1' -1

# The content of this file will be appended to the top of the psm1 module file. This is useful for custom procesedures after all module functions are loaded.
#EndRegion './suffix.ps1' 2