PenguinConverters.Keyra.PowerShell.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>PenguinConverters.Keyra.PowerShell</name>
    </assembly>
    <members>
        <member name="T:PenguinConverters.Keyra.PowerShell.CloseKeyraVaultCmdlet">
             <summary>
             Closes an opened vault or repository, releasing the key material it holds.
             
             Accepts anything <c>Open-KeyraVault</c> or <c>Open-KeyraRepository</c> hands back — a
             <see cref="T:PenguinConverters.Keyra.VaultReader"/> (export package), a <see cref="T:PenguinConverters.Keyra.VaultSession"/> (a vault in a live
             repository), or a <see cref="T:PenguinConverters.Keyra.VaultRepository"/> (which also closes every session opened from it).
             </summary>
             <example>
             <code>Close-KeyraVault -Vault $vault</code>
             <code>Close-KeyraVault -Vault $repo # closes the repository and its sessions</code>
             </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.CloseKeyraVaultCmdlet.Vault">
            <summary>
            The vault, session or repository to close.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.CloseKeyraVaultCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.DecryptorSource">
            <summary>
            Builds the SDK <see cref="T:PenguinConverters.Keyra.Decryptor"/> from the parameter combinations the cmdlets share:
            a key file path (content-sniffed by the SDK: .keyra package, armored share file, key.json,
            or vault directory), or armored share text held in memory.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.DecryptorSource.Build(System.String,System.String,System.Security.SecureString,System.Security.SecureString[])">
            <summary>
            Builds a <see cref="T:PenguinConverters.Keyra.Decryptor"/> from either a key file path or armored share text.
            Exactly one of <paramref name="keyFilePath"/> / <paramref name="share"/> must be set —
            the cmdlets' parameter sets guarantee that.
            </summary>
            <param name="keyFilePath">Resolved filesystem path of the key source, or null.</param>
            <param name="share">Armored share text (KEYRA: ... :ARYEK), or null.</param>
            <param name="password">Single chain password, or null for password-less chains.</param>
            <param name="passwords">Ordered chain passwords for multi-password chains, or null.</param>
            <returns>The built decryptor; the caller owns and disposes it.</returns>
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet">
            <summary>
            Gets one or all secrets from an opened VaultReader.
            When the vault is received via pipeline, it is automatically disposed after processing.
            When passed as a parameter, the caller is responsible for disposal via Close-KeyraVault.
            Supports cancellation via Ctrl+C (StopProcessing).
            </summary>
            <example>
            <code>$secrets = Get-KeyraVaultSecret -Vault $vault</code>
            <code>$secret = Get-KeyraVaultSecret -Vault $vault -Name "my-api-key"</code>
            <code>Open-KeyraVault -Path "vault.keyra" -Password $pw | Get-KeyraVaultSecret</code>
            </example>
        </member>
        <member name="F:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet._pipelineVaults">
            <summary>
            Vaults received via pipeline that need disposal after processing.
            </summary>
        </member>
        <member name="F:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet._cts">
            <summary>
            Cancellation token source cancelled by StopProcessing (Ctrl+C).
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet.Vault">
            <summary>
            The VaultReader to read secrets from. Accepts pipeline input.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet.Name">
            <summary>
            Optional secret identifier. When specified, returns only the matching secret.
            When omitted, returns all secrets.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet.EndProcessing">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet.StopProcessing">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.GetKeyraVaultSecretCmdlet.DisposePipelineVaults">
            <summary>
            Disposes all VaultReaders that were received via pipeline input.
            </summary>
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet">
            <summary>
            Base for cmdlets that consume a Keyra <see cref="T:PenguinConverters.Keyra.Decryptor"/>: the three ways to name
            the key source (a key file path, armored share text, or a prebuilt decryptor from
            <c>New-KeyraDecryptor</c>) and the decryptor lifecycle. The decryptor is built once per
            invocation in <see cref="M:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.BeginProcessing"/> — not per pipeline item, so the key derivation
            cost is paid once for a whole pipeline — and disposed only when this cmdlet built it; a
            caller-supplied <see cref="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.Decryptor"/> stays alive for reuse.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.KeyFile">
            <summary>
            Path to the key source. The content decides how it is read: a .keyra package (whatever
            it is named), an armored share text file (KEYRA: ... :ARYEK), a raw key document
            (key.json / .key), or a vault directory / its vault.json.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.Share">
            <summary>
            Armored vault share text (KEYRA: ... :ARYEK) held in memory — from the clipboard, an
            environment variable, or a secrets store. Plain and decoratively shaped armor alike.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.Decryptor">
            <summary>
            A decryptor built once with <c>New-KeyraDecryptor</c> and reused across calls. This
            cmdlet never disposes it — the caller owns its lifetime.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.Password">
            <summary>
            Password for the key. Optional if the chain needs no password (e.g. Windows / Active
            Directory shares).
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.Passwords">
            <summary>
            Ordered passwords for authenticator chains that require more than one. Mutually
            exclusive with <see cref="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.Password"/>.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.ActiveDecryptor">
            <summary>The decryptor to use for this invocation. Valid between Begin and End processing.</summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.BeginProcessing">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.EndProcessing">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.KeyraDecryptorConsumerCmdlet.StopProcessing">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet">
            <summary>
            Builds a reusable Keyra <see cref="T:PenguinConverters.Keyra.Decryptor"/> from a key source, paying the key
            derivation once. Pass the result to <c>Protect-KeyraSecret</c> / <c>Unprotect-KeyraSecret</c>
            via <c>-Decryptor</c>, and call <c>.Dispose()</c> on it when finished.
            </summary>
            <example>
            <code>
            $d = New-KeyraDecryptor -Share (Get-Clipboard) -Password $pw
            $plain = $cipher | Unprotect-KeyraSecret -Decryptor $d
            $d.Dispose()
            </code>
            </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet.KeyFile">
            <summary>
            Path to the key source. The content decides how it is read: a .keyra package (whatever
            it is named), an armored share text file (KEYRA: ... :ARYEK), a raw key document
            (key.json / .key), or a vault directory / its vault.json.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet.Share">
            <summary>
            Armored vault share text (KEYRA: ... :ARYEK) held in memory — from the clipboard, an
            environment variable, or a secrets store. Plain and decoratively shaped armor alike.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet.Password">
            <summary>
            Password for the key. Optional if the chain needs no password (e.g. Windows / Active
            Directory shares).
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet.Passwords">
            <summary>
            Ordered passwords for authenticator chains that require more than one. Mutually
            exclusive with <see cref="P:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet.Password"/>.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.NewKeyraDecryptorCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.OpenKeyraRepositoryCmdlet">
             <summary>
             Opens a live Keyra repository for reading and writing.
             
             This is the writable counterpart to <c>Open-KeyraVault -Path</c>, which opens a read-only
             <c>.keyra</c> export package. A repository is the directory the desktop app and CMDKEYRA work
             against, so secrets written through it are secrets the app will see.
             
             The repository holds any vault keys it unlocks, so close it when done.
             </summary>
             <example>
             <code>$repo = Open-KeyraRepository -Path "C:\keyra"</code>
             <code>$repo | Get-Member</code>
             </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.OpenKeyraRepositoryCmdlet.Path">
            <summary>
            Path to the Keyra repository directory (the one containing <c>vaults/</c>).
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.OpenKeyraRepositoryCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet">
             <summary>
             Opens a vault, either from an exported package or from a live repository.
             
             The two are different things, so they return different objects:
             <list type="bullet">
             <item><b>-Path</b> opens a <c>.keyra</c> export package and returns a read-only
             <see cref="T:PenguinConverters.Keyra.VaultReader"/>.</item>
             <item><b>-Repository</b> opens a vault inside a live repository (see <c>Open-KeyraRepository</c>)
             and returns a writable <see cref="T:PenguinConverters.Keyra.VaultSession"/> — secrets set through it are seen by the desktop
             app.</item>
             </list>
             </summary>
             <example>
             <code>$vault = Open-KeyraVault -Path "team-vault.keyra" -Password $pw</code>
             <code>$repo = Open-KeyraRepository -Path "C:\keyra"
             $vault = Open-KeyraVault -Repository $repo -Name "Prod" -Password $pw</code>
             </example>
        </member>
        <member name="F:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.PackageParameterSet">
            <summary>Parameter set for opening an exported .keyra package (read-only).</summary>
        </member>
        <member name="F:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.RepositoryParameterSet">
            <summary>Parameter set for opening a vault in a live repository (read/write).</summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.Path">
            <summary>
            Path to the .keyra vault export file.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.Repository">
            <summary>
            An open repository, from <c>Open-KeyraRepository</c>.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.Name">
            <summary>
            The vault's name within the repository.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.Password">
            <summary>
            The vault's password(s). Supply one per authenticator in the vault's chain, in order. Omit for a
            vault with no authenticators — its key is then derived without a credential.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.OpenFromRepository">
            <summary>
            Opens a vault in a live repository and returns a writable session.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.OpenKeyraVaultCmdlet.OpenFromPackage">
            <summary>
            Opens an exported .keyra package and returns a read-only reader.
            </summary>
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.ProtectKeyraSecretCmdlet">
            <summary>
            Encrypts a plaintext value using a Keyra key. The key comes from a key file, an armored
            share text, or a reusable decryptor built with <c>New-KeyraDecryptor</c>.
            </summary>
            <example>
            <code>$cipher = Protect-KeyraSecret -KeyFile "vault.key.keyra" -Password $pw -Value "hello"</code>
            </example>
            <example>
            <code>$cipher = Protect-KeyraSecret -Share (Get-Clipboard) -Password $pw -Value $secret</code>
            </example>
            <example>
            <code>$ciphers = $secrets | Protect-KeyraSecret -Decryptor $d</code>
            </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.ProtectKeyraSecretCmdlet.Value">
            <summary>
            Plaintext value to encrypt, as a <see cref="T:System.Security.SecureString"/> so it never appears in command
            history / transcripts as a plain argument. Accepts pipeline input.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.ProtectKeyraSecretCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.RemoveKeyraVaultSecretCmdlet">
             <summary>
             Deletes a secret from a vault opened from a live repository.
             
             The secret file is removed by the same engine that wrote it, so there is no chance of orphaning a
             file by deriving its name a second, different way.
             
             Destructive, so it confirms by default — pass <c>-Confirm:$false</c> to suppress that.
             </summary>
             <example>
             <code>Remove-KeyraVaultSecret -Vault $vault -Name "old-api-key"</code>
             </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.RemoveKeyraVaultSecretCmdlet.Vault">
            <summary>
            The writable vault, from <c>Open-KeyraVault -Repository</c>.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.RemoveKeyraVaultSecretCmdlet.Name">
            <summary>
            The name of the secret to delete.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.RemoveKeyraVaultSecretCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.SecureStringHelper">
            <summary>
            Conversions between <see cref="T:System.Security.SecureString"/> and transient <c>char[]</c>/<see cref="T:System.Security.SecureString"/>
            that never route secret text through a managed <c>string</c> (which cannot be erased from memory).
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.SecureStringHelper.ToSecureString(System.ReadOnlySpan{System.Char})">
            <summary>
            Builds a read-only <see cref="T:System.Security.SecureString"/> from a char span without an intermediate string.
            </summary>
            <param name="chars">The plaintext characters.</param>
            <returns>A read-only secure string.</returns>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.SecureStringHelper.ToChars(System.Security.SecureString)">
            <summary>
            Copies a <see cref="T:System.Security.SecureString"/> into a fresh <c>char[]</c> via an unmanaged BSTR, never a
            managed string. The caller MUST zero the returned array (e.g. <see cref="M:System.Array.Clear(System.Array)"/>)
            once finished.
            </summary>
            <param name="secure">The secure string to read.</param>
            <returns>The plaintext characters; caller-owned and must be zeroed after use.</returns>
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet">
             <summary>
             Writes a secret into a vault opened from a live repository: adds it, or updates it in place when it
             already exists.
             
             The value is encrypted under the vault key and persisted through the same path the desktop app and
             CMDKEYRA use, so what is written here is what the app reads.
             
             Only a <see cref="T:PenguinConverters.Keyra.VaultSession"/> (from <c>Open-KeyraVault -Repository</c>) can be written to — a
             <c>.keyra</c> export package is a read-only snapshot, not a vault.
             </summary>
             <example>
             <code>$repo = Open-KeyraRepository -Path "C:\keyra"
             $vault = Open-KeyraVault -Repository $repo -Name "Prod" -Password $pw
             Set-KeyraVaultSecret -Vault $vault -Name "api-key" -Value $secret</code>
             <code>Set-KeyraVaultSecret -Vault $vault -Name "api-key" -Notes "rotated" # metadata only</code>
             </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Vault">
            <summary>
            The writable vault, from <c>Open-KeyraVault -Repository</c>.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Name">
            <summary>
            The secret's name. Any characters are allowed — the storage layer derives a filesystem-safe
            filename from it.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Value">
            <summary>
            The secret value. Omit to leave an existing secret's value untouched and edit only its metadata —
            you do not have to know the current value to re-tag a secret.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Username">
            <summary>Optional username. Omit to leave any existing one alone.</summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Url">
            <summary>Optional URL. Omit to leave any existing one alone.</summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Notes">
            <summary>Optional notes. Omit to leave any existing one alone.</summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.Expires">
            <summary>Optional expiry. Omit to use the key algorithm's default.</summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.SetKeyraVaultSecretCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.UnprotectKeyraSecretCmdlet">
            <summary>
            Decrypts an encrypted value using a Keyra key. The key comes from a key file, an armored
            share text, or a reusable decryptor built with <c>New-KeyraDecryptor</c>.
            </summary>
            <example>
            <code>Unprotect-KeyraSecret -KeyFile "vault.key.keyra" -Password $pw -Value $cipher</code>
            </example>
            <example>
            <code>Unprotect-KeyraSecret -Share $env:MYAPP_KEYRA_SHARE -Password $pw -Value $cipher</code>
            </example>
            <example>
            <code>$plains = $ciphers | Unprotect-KeyraSecret -Decryptor $d</code>
            </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.UnprotectKeyraSecretCmdlet.Value">
            <summary>
            Base64-encoded ciphertext to decrypt. Accepts pipeline input.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.UnprotectKeyraSecretCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="T:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet">
            <summary>
            Decrypts a vault secret's value, property, or file attachment.
            Text values are returned as SecureString to prevent plaintext from lingering in session memory.
            File attachments can be saved directly to disk.
            </summary>
            <example>
            <code>$secure = Unprotect-KeyraVaultSecret -Secret $secret</code>
            <code>$secure = Unprotect-KeyraVaultSecret -Secret $secret -Property "ApiKey"</code>
            <code>Unprotect-KeyraVaultSecret -Secret $secret -File "document.txt" -OutFile "C:\output\doc.txt"</code>
            <code>Open-KeyraVault -Path "vault.keyra" -Password $pw | Get-KeyraVaultSecret | Unprotect-KeyraVaultSecret</code>
            </example>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.Secret">
            <summary>
            The VaultSecret to decrypt. Accepts pipeline input.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.Property">
            <summary>
            Name of a secret property to decrypt instead of the main value.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.File">
            <summary>
            Name of an encrypted file attachment to decrypt.
            </summary>
        </member>
        <member name="P:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.OutFile">
            <summary>
            Output path for decrypted file content. When omitted with -File, writes raw bytes to the pipeline.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.ProcessRecord">
            <inheritdoc />
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.DecryptValue">
            <summary>
            Decrypts the main secret value and outputs as SecureString.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.DecryptProperty">
            <summary>
            Decrypts a secret property and outputs as SecureString.
            </summary>
        </member>
        <member name="M:PenguinConverters.Keyra.PowerShell.UnprotectKeyraVaultSecretCmdlet.DecryptFile">
            <summary>
            Decrypts a file attachment and either saves to disk or outputs raw bytes.
            </summary>
        </member>
    </members>
</doc>