Summary: Provider for Visual Sourcesafe.

This provider is not updated for the newest MSH preview release, and it is not completed either. But it should give an example of how to implement a provider for other developers.

It usees the VSS OLE automation library, so that is needed (see the using SourceSafeTypeLib at the top). That library can be generated using the tlbimp tool from the .NET Framework SDK.

		 using System;
		 using [SourceSafeTypeLib;]
		 using System.Management.Automation;
		 using [System.Management.Automation.CmdletProvider;]
	

		 namespace Walkabout
		 {
		 	/// <summary>
	

/// Summary description for VssCmdletProvider.
///

		    /// The [ProviderDeclaration] attribute signifies to the Microsoft Command Shell
		    /// that this class implements a [CmdletProvider.]  The first parameter is the
		    /// default friendly name for the provider. It can be modified by the user.
		    /// The second parameter is the "real" name of the provider. It is used along
		    /// with assembly information to generate a fully-qualified unambiguous name
		    /// for the provider. The third parameter is the provider supported capabilities.
		    /// </summary>
		    /// 
		    [ProviderDeclaration("VSS", "Visual SourceSafe Provider", ProviderCapabilityFlags.None )]
	

public class VssCmdletProvider : NavigationCmdletProvider,

		                                        [IPropertyCmdletProvider,]
		                                        [IMultivaluePropertyCmdletProvider,]
		                                        [IDynamicPropertyCmdletProvider]                                        
	

{

		        private [VSSDatabaseClass] _Vssdb;
	

		        public [VssCmdletProvider()]
	

{

		        }
	

		        #region [CmdletProvider] Overrides
		        // [CmdletProvider] is a base class for a provider that hooks into the 
		        // namespace.
	

		        /// <summary>
		        /// Gives the provider the opportunity to initialize itself.
		        /// </summary>
		        /// 
		        /// <remarks>
		        /// The default implementation in [CmdletProvider] does nothing. 
		        /// </remarks>
		        /// 
		        protected override void Start ()
		        {
		            _Vssdb = new [VSSDatabaseClass();]
		        }
	

		        /// <summary>
		        /// Uninitialize the provider.
		        /// </summary>
		        /// 
		        /// <remarks>
		        /// This is the time to free up any resources that the provider
		        /// was using.
		        /// 
		        /// The default implementation in [CmdletProvider] does nothing.
		        /// </remarks>
		        /// 
		        protected override void Stop ()
		        {
		            _Vssdb = null;
		        }
	

		        #endregion [CmdletProvider] Overrides
	

		        #region [DriveCmdletProvider] Overrides
		        // [DriveCmdletProvider] is base class for a provider that hooks 
		        // into the Microsoft Command Shell namespace and supports the mounting of drives.
		        /// <summary>
		        /// Gives the provider an opportunity to validate the virtual drive
		        /// that is being added. It also allows the provider to modify parts
		        /// of the [DriveInfo] object. This may be done for performance or
		        /// reliability reasons or to provide extra data to all calls using
		        /// the Drive.
		        /// </summary>
		        /// 
		        /// <param name="drive">
		        /// The proposed new drive.
		        /// </param>
		        /// 
		        /// <returns>
		        /// The new drive that is to be added to the MSH namespace. This
		        /// can either be the same <paramref name="drive"/> object that
		        /// was passed in or a modified version of it.
		        /// 
		        /// The default implementation returns the drive that was passed.
		        /// </returns>
		        /// 
		        /// <remarks>
		        /// This method gives the provider an opportunity to set the 
		        /// [drivePrivateData] of the Drive object and to verify
		        /// the other parameters. Implementers of this method should verify that
		        /// the root exists and that a connection to the data store can be made.
		        /// Any failures should be written to the [WriteErrorObject] method and
		        /// null should be returned.
		        ///
		        /// </remarks>
		        /// 
		        protected override [DriveInfo] [NewDrive] [(DriveInfo] drive)
		        {
		            // Open a new connection to this VSS database
		            if (drive == null)
		            {
		                throw new ArgumentNullException("drive");
		            }
	

		            if (!ItemExists(drive.Root))
		            {
		                throw new ArgumentException("Drive does not exist. The root path does not exist.");
		            }
	

		            return drive;
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to clean up any provider specific data
		        /// for the drive that is going to be removed.
		        /// </summary>
		        /// 
		        /// <param name="drive">
		        /// The Drive object the represents the mounted drive.
		        /// </param>
		        /// 
		        /// <returns>
		        /// If the drive can be removed it should return the drive that was passed
		        /// in. If the drive cannot be removed, null should be returned and an
		        /// exception should be written to the [WriteErrorObject] method.
		        /// 
		        /// The default implementation returns the drive that was passed.
		        /// </returns>
		        /// 
		        protected override [DriveInfo] [RemoveDrive] [(DriveInfo] drive)
		        {
		            // TODO: Remove the drive
		            return drive;
		        }
	

		        /// <summary>
		        /// Gives the provider the ability to map drives after initialization.
		        /// </summary>
		        /// 
		        /// <returns>
		        /// A drive array with the drives that should be added. The default implementation
		        /// returns an empty array.
		        /// </returns>
		        /// 
		        /// <remarks>
		        /// After the Start method is called on a provider, the [InitializeDefaultDrives]
		        /// method is called. This is an opportunity for the provider to
		        /// mount drives that are important to it. For instance, the Active Directory
		        /// provider might mount a drive for the [defaultNamingContext] if the 
		        /// machine is joined to a domain.
		        /// 
		        /// All providers should mount a root drive to help the user with discoverability.
		        /// This root drive might contain a listing of a set of locations that would be
		        /// interesting as roots for other mounted drives. For instance, the Active
		        /// Directory provider my create a drive that lists the naming contexts found
		        /// in the namingContext attributes on the RootDSE. This will help users
		        /// discover interesting mount points for other drives.
		        /// </remarks>
		        /// 
		        protected override DriveInfo[] [InitializeDefaultDrives] ()
		        {
		            [SourceSafeTypeLib.VSSDatabaseClass] vssdb = new [VSSDatabaseClass();]
		            Credential crd = new Credential();
	

		            [crd.UserName] = vssdb.Username;
	

		            DriveInfo[] drives = new DriveInfo[] {
		                new [DriveInfo(vssdb.SrcSafeIni,] "VSS", "$/", "Current [SourceSafe] Server", null, crd)
		            };
	

		            return drives;
		        } 
	

		        #endregion [DriveCmdletProvider] Overrides
	

		        #region [ItemCmdletProvider] overrides
		        // The base class for a provider of a single item,that hooks into the 
		        // Microsoft Command Shell namespace.
		        /// <summary>
		        /// Gets the item at the specified path. 
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to retrieve. 
		        /// </param>
		        /// 
		        /// 
		        /// <returns>
		        /// Nothing is returned, but all objects should be written to the [WriteItemObject] 
		        /// method.
		        /// </returns>
		        /// 
		        protected override void [GetItem] (string path)
		        {
		            //Get the item at the specified path and write it using [WriteItemObject]
		            // [WriteItemObject(yourretrievedobject);]
		            if (path == null)
		                throw new ArgumentNullException("path");
		        }
	

		        /// <summary>
		        /// Sets the item specified by the path. 
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to set.
		        /// </param>
		        /// 
		        /// <param name="value">
		        /// The value of the item specified by the path.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing is returned, but the item that is set should be written to the 
		        /// [WriteItemObject] method.
		        /// </returns>
		        /// 
		        protected override void [SetItem] (string path, object value)
		        {
		            [//WriteItemObject(item);]
		        }
	

		        /// <summary>
		        /// Clears the item specified by the path. 
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to clear.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing is returned, but the item that is cleared should be written to the 
		        /// [WriteItemObject] method.
		        /// </returns>
		        /// 
		        protected override void [ClearItem] (string path)
		        {
		            [//WriteItemObject(item);]
		        }
	

		        /// <summary>
		        /// Invokes the default action on the specified item. The default implementation
		        /// does nothing.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to perform the default action on.
		        /// </param>
		        /// 
		        protected override void [InvokeDefaultAction] (string path)
		        {
		        }
	

		        #endregion [ItemCmdletProvider] overrides
	

		        #region [ContainerCmdletProvider] overrides
		        // [ContainerCmdletProvider] is base class for a provider of a container 
		        // of items, that hooks into the Microsoft Command Shell namespace.
		        /// <summary>
		        /// Gets the children of the item at the specified path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path (or name in a flat namespace) to the item from which to retrieve the children.
		        /// </param>
		        /// 
		        /// <param name="recurse">
		        /// True if all children in a subtree should be retrieved, false if only a single
		        /// level of children should be retrieved. This parameter should only be true for
		        /// the [NavigationProviderBase] derived class.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing is returned, but all children should be written to the [WriteItemObject] method.
		        /// </returns>
		        /// 
		        protected override void [GetChildItems] (string path, bool recurse)
		        {
		            // [WriteItemObject(item)]    
		            //
		            // If more than one item is the norm and the operation may take some
		            // time try writing each individual item to the [WriteItemObject] method
		            // one at a time. This allows the user to get a streaming behavior.
		        }
	

		        /// <summary>
		        /// Gets names of the children of the specified path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item from which to retrieve the child names.
		        /// </param>
		        /// 
		        /// <param name="returnAllContainers">
		        /// If true, the provider should return all containers, even if they don't match the filter.
		        /// If false, the provider should only return containers that do match the filter.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing is returned, but all names should be written to the [WriteItemObject] method.
		        /// </returns>
		        /// 
		        /// <remarks>
		        /// The child names are the leaf portion of the path. Example, for the file system
		        /// the name for the path c:\windows\system32\foo.dll would be foo.dll or for
		        /// the directory c:\windows\system32 would be system32. For Active Directory the
		        /// child names would be RDN values of the child objects of the container.
		        /// </remarks>
		        /// 
		        protected override void [GetChildNames] (string path, bool [returnAllContainers)]
		        {
		            // [WriteItemObject(nameofitem)]    - if a single item as your child normally
		        }
	

		        /// <summary>
		        /// Renames the item at the specified path to the new name provided.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to rename.
		        /// </param>
		        /// 
		        /// <param name="newName">
		        /// The name to which the item should be renamed. This name should always be 
		        /// relative to the parent container.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing is returned, but all renamed items should be written to the [WriteItemObject.]
		        /// </returns>
		        /// 
		        protected override void [RenameItem] (string path, string newName)
		        {
		            // [WriteItemObject(renamedobject);]        - writes the renamed object
		        }
	

		        /// <summary>
		        /// Creates a new item at the specified path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to create.
		        /// </param>
		        /// 
		        /// <param name="type">
		        /// The provider defined type for the object to create.
		        /// </param>
		        ///
		        /// <param name="newItem">
		        /// This is a provider specific type that the provider can use to create a new
		        /// instance of an item at the specified path.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing is returned, but all new items should be written to the [WriteItemObject] method.
		        /// </returns>
		        /// 
		        protected override void [NewItem] (string path, string type, object newItem)
		        {
		            // [WriteItemObject(item);]                 - writes the newly created object
		        }
	

		        /// <summary>
		        /// Removes (deletes) the item at the specified path 
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to remove. 
		        /// </param>
		        /// 
		        /// <param name="recurse">
		        /// True if all children in a subtree should be removed, false if only 
		        /// the item at the specified path should be removed. This parameter should 
		        /// only be true for [NavigationProviderBase] and its derived classes.
		        /// </param>
		        /// 
		        protected override void [RemoveItem] (string path, bool recurse)
		        {
		        }
	

		        /// <summary>
		        /// Determines if an item exists at the specified path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to see if it exists. 
		        /// </param>
		        /// 
		        /// <returns>
		        /// True if the item exists, false otherwise.
		        /// </returns>
		        /// 
		        protected override bool [ItemExists] (string path)
		        {
		            return false;
		        }
	

		        /// <summary>
		        /// Determines if the item at the specified path has children.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to see if it has children.
		        /// </param>
		        ///
		        /// <returns>
		        /// True if the item has children, false otherwise.
		        /// </returns>
		        /// 
		        /// <remarks>
		        /// For implementers of [ContainerCmdletProvider] classes and those derived from it, 
		        /// if a null or empty path is passed,
		        /// the provider should consider any items in the data store to be children
		        /// and return true.
		        /// </remarks>
		        /// 
		        protected override bool [HasChildItems] (string path)
		        {
		            return false;
		        }
	

		        /// <summary>
		        /// Copies an item at the specified path to an item at the <paramref name="copyPath" />.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path of the item to copy.
		        /// </param>
		        /// 
		        /// <param name="copyPath">
		        /// The path of the item to copy to.
		        /// </param>
		        /// 
		        /// <param name="recurse">
		        /// Tells the provider to recurse sub-containers when copying.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing. All objects that are copied should be written to the [WriteItemObject] method.
		        /// </returns>
		        /// 
		        protected override void [CopyItem] (string path, string copyPath, bool recurse)
		        {
		            // [WriteItemObject(item);]   - write items as they get copied.
		        }
	

		        #endregion [ContainerCmdletProvider] overrides
	

		        #region [NavigationCmdletProvider] overrides
		        // The base class for a provider of a tree of items, that hooks into 
		        // the Microsoft Command Shell namespace.
		        /// <summary>
		        /// Combines two strings with a provider specific path separator.
		        /// </summary>
		        /// 
		        /// <param name="parent">
		        /// The parent segment of a path to be joined with the child.
		        /// </param>
		        /// 
		        /// <param name="child">
		        /// The child segment of a path to be joined with the parent.
		        /// </param>
		        /// 
		        /// <returns>
		        /// A string that represents the parent and child segments of the path
		        /// joined by a path separator.
		        /// </returns>
		        /// 
		        /// <remarks>
		        /// This method should use lexical joining of two path segments with a path
		        /// separator character. It should not validate the path as a legal fully
		        /// qualified path in the provider namespace as each parameter could be only
		        /// partial segments of a path and combined they may not generate a fully
		        /// qualified path.
		        /// Example: the file system provider may get "windows\system32" as the parent
		        /// parameter and "foo.dll" as the child parameter. The method should join these
		        /// with the "\" separator and return "windows\system32\foo.dll". Note that
		        /// the returned path is not a fully qualified file system path.
		        /// 
		        /// Also beware that the path segments may contain characters that are illegal
		        /// in the provider namespace. These characters are most likely being used
		        /// for globbing and should not be removed by the implementation of this method.
		        /// 
		        /// The default implementation will take paths with '/' or '\' as the path
		        /// separator and normalize the path separator to '/' and then combine
		        /// the child and parent with a '/'.
		        /// </remarks>
		        /// 
		        protected override string [MakePath] (string parent, string child)
		        {
		            return null;    // return combined path;
		        }
	

		        /// <summary>
		        /// Removes the child segment of a path and returns the remaining parent
		        /// portion.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// A full or partial provider specific path. The path may be to an item 
		        /// that may or may not exist.
		        /// </param>
		        /// 
		        /// <param name="root">
		        /// The fully qualified path to the root of a drive. This parameter may be null
		        /// or empty if a mounted drive is not in use for this operation. If this parameter
		        /// is not null or empty the result of the method should not be a path to a container
		        /// that is a parent or in a different tree than the root.
		        /// </param>
		        /// 
		        /// <returns>
		        /// The path of the parent of the path parameter.
		        /// </returns>
		        ///
		        /// <remarks>
		        /// This should be a lexical splitting of the path on the path separator character
		        /// for the provider namespace. For example, the file system provider should look
		        /// for the last "\" and return everything to the left of the "\".
		        /// 
		        /// The default implementation accepts paths that have both '/' and '\' as the
		        /// path separator. It first normalizes the path to have only '/' separators
		        /// and then splits the parent path off at the last '/' and returns it.
		        /// </remarks>
		        /// 
		        protected override string [GetParentPath] (string path, string root)
		        {
		            return null;    // return parentpath;
		        }
	

		        /// <summary>
		        /// Gets the name of the leaf element in the specified path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The full or partial provider specific path.
		        /// </param>
		        /// 
		        /// <returns>
		        /// The leaf element in the path.
		        /// </returns>
		        /// 
		        /// <remarks>
		        /// This should be implemented as a split on the path separator. The characters
		        /// in the fullPath may not be legal characters in the namespace but may be
		        /// used in globing or regular expression matching. If the path contains no
		        /// path separators the path should be returned unmodified.
		        /// 
		        /// The default implementation accepts paths that have both '/' and '\' as the
		        /// path separator. It first normalizes the path to have only '/' separators
		        /// and then splits the child name off at the last '/' and returns it.
		        /// </remarks>
		        /// 
		        protected override string [GetChildName] (string path)
		        {
		            return null;    // return childname;
		        }
	

		        /// <summary>
		        /// Determines if the specified object is a container
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to determine if it is a container.
		        /// </param>
		        /// 
		        /// <returns>
		        /// true if the item specified by path exists and is a container, 
		        /// false otherwise.
		        /// </returns>
		        /// 
		        protected override bool [IsItemContainer] (string path)
		        {
		            return false;   //return true item is container
		        }
	

		        /// <summary>
		        /// Moves the item specified by path to the specified destination.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to be moved.
		        /// </param>
		        /// 
		        /// <param name="destination">
		        /// The path of the destination container.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing. All objects that are moved should be written to the [WriteItemObject] method.
		        /// </returns>
		        /// 
		        protected override void [MoveItem] (string path, string destination)
		        {
		            // [WriteItemObject(item);]   - write items as they get moved.
		        }
	

		        #endregion [NavigationCmdletProvider] overrides
	

		        #region [IPropertyProvider] Members
	

		        // [IPropertyProvider] is interface for a provider of properties,that hooks 
		        // into the Microsoft Command Shell namespace.
	

		        /// <summary>
		        /// Gets the properties of the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to retrieve properties from.
		        /// </param>
		        /// 
		        /// <param name="providerSpecificPickList">
		        /// A list of properties that should be retrieved. If this parameter is null
		        /// or empty, all properties should be retrieved.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing. An instance of [ShellObject] representing the properties that were retrieved
		        /// should be passed to the [WritePropertyObject()] method.
		        /// </returns>
		        /// 
		        public void [GetProperty] (string path, string[] [providerSpecificPickList)]
		        {
		            // [ShellObject] shellObject = [ShellObject.Create(null);]
		            // [shellObject.AddNote(propertyName,] propertyValue);
		            [//WritePropertyObject(] shellObject );
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// get-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="providerSpecificPickList">
		        /// A list of properties that were specified on the command line.  This parameter
		        /// may be empty or null if the properties are being piped into the command.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [GetPropertyDynamicParameters(] string path, string[] [providerSpecificPickList] )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Sets the specified properties of the item at the specified path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item to set the properties on.
		        /// </param>
		        /// 
		        /// <param name="property">
		        /// A [ShellObject] which contains a collection of the name, type, value 
		        /// of the properties to be set.
		        /// </param>
		        /// 
		        /// <returns>
		        /// Nothing. An instance of [ShellObject] representing the properties that were set
		        /// should be passed to the [WritePropertyObject()] method.
		        /// </returns>
		        /// 
		        public void [SetProperty] (string path, [ShellObject] property)
		        {
		            [//WritePropertyObject(] shellObject );
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// set-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyValue">
		        /// A [ShellObject] which contains a collection of the name, and value 
		        /// of the properties to be set if they were specified on the command line.
		        /// The [ShellObject] could be empty or null if the parameters are being
		        /// piped into the command.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [SetPropertyDynamicParameters(] string path, [ShellObject] propertyValue )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Clears a property of the item at the specified path.
		        /// </summary>
		        ///
		        /// <param name="path">
		        /// The path to the item on which to clear the property.
		        /// </param>
		        ///
		        /// <param name="propertyToClear">
		        /// The name of the property to clear.
		        /// </param>
		        ///
		        public void [ClearProperty] (string path, string[] [propertyToClear)]
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// clear-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyToClear">
		        /// The name of the property to clear. This parameter may be null or
		        /// empty if the properties to clear are being piped into the command.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [ClearPropertyDynamicParameters(] string path, string[] [propertyToClear] )
		        {
		            return null;
		        }
	

		        #endregion
	

		        #region [IDynamicPropertyCmdletProvider] Methods
	

		        /// <summary>
		        /// Copies a property of the item at the specified path to a new property on the 
		        /// destination item.
		        /// </summary>
		        /// 
		        /// <param name="sourcePath">
		        /// The path to the item from which to copy the property.
		        /// </param>
		        /// 
		        /// <param name="sourceProperty">
		        /// The name of the property to copy.
		        /// </param>
		        /// 
		        /// <param name="destinationPath">
		        /// The path to the item on which to copy the property to.
		        /// </param>
		        /// 
		        /// <param name="destinationProperty">
		        /// The destination property to copy to.
		        /// </param>
		        /// 
		        public void [CopyProperty(] string sourcePath, string sourceProperty, string destinationPath, string destinationProperty )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// copy-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="sourcePath">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="sourceProperty">
		        /// The name of the property to copy.
		        /// </param>
		        /// 
		        /// <param name="destinationPath">
		        /// The path to the item on which to copy the property to.
		        /// </param>
		        /// 
		        /// <param name="destinationProperty">
		        /// The destination property to copy to.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [CopyPropertyDynamicParameters(] string sourcePath, string sourceProperty, string destinationPath, string destinationProperty )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Moves a property on an item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="sourcePath">
		        /// The path to the item from which to move the property.
		        /// </param>
		        /// 
		        /// <param name="sourceProperty">
		        /// The name of the property to move.
		        /// </param>
		        /// 
		        /// <param name="destinationPath">
		        /// The path to the item on which to move the property to.
		        /// </param>
		        /// 
		        /// <param name="destinationProperty">
		        /// The destination property to move to.
		        /// </param>
		        /// 
		        public void [MoveProperty(] string sourcePath, string sourceProperty, string destinationPath, string destinationProperty )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// move-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="sourcePath">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="sourceProperty">
		        /// The name of the property to copy.
		        /// </param>
		        /// 
		        /// <param name="destinationPath">
		        /// The path to the item on which to copy the property to.
		        /// </param>
		        /// 
		        /// <param name="destinationProperty">
		        /// The destination property to copy to.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [MovePropertyDynamicParameters(] string sourcePath, string sourceProperty, string destinationPath, string destinationProperty )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Creates a new property on the specified item
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item on which the new property should be created.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The name of the property that should be created.
		        /// </param>
		        /// 
		        /// <param name="type">
		        /// The type of the property that should be created.
		        /// </param>
		        /// 
		        /// <param name="value">
		        /// The new value of the property that should be created.
		        /// </param>
		        /// 
		        public void [NewProperty(] string path, string propertyName, string type, object value )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// new-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The name of the property that should be created.
		        /// </param>
		        /// 
		        /// <param name="type">
		        /// The type of the property that should be created.
		        /// </param>
		        /// 
		        /// <param name="value">
		        /// The new value of the property that should be created.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [NewPropertyDynamicParameters(] string path, string propertyName, string type, object value )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Removes a property on the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item from which the property should be removed.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The name of the property to be removed.
		        /// </param>
		        /// 
		        public void [RemoveProperty(] string path, string propertyName )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// remove-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The name of the property that should be removed.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [RemovePropertyDynamicParameters(] string path, string propertyName )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Renames a property of the item at the specified path
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item on which to rename the property.
		        /// </param>
		        /// 
		        /// <param name="sourceProperty">
		        /// The property to rename.
		        /// </param>
		        /// 
		        /// <param name="destinationProperty">
		        /// The new name of the property.
		        /// </param>
		        /// 
		        public void [RenameProperty(] string path, string sourceProperty, string destinationProperty )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// rename-property cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="sourceProperty">
		        /// The property to rename.
		        /// </param>
		        /// 
		        /// <param name="destinationProperty">
		        /// The new name of the property.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [RenamePropertyDynamicParameters(] string path, string sourceProperty, string destinationProperty )
		        {
		            return null;
		        }
	

		        #endregion
	

		        #region [IMultivaluePropertyCmdletProvider] Methods
	

		        /// <summary>
		        /// Adds a property value on the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item on which the property should be added.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to add.
		        /// </param>
		        /// 
		        /// <param name="propertyValue">
		        /// The property to add the value on.
		        /// </param>
		        /// 
		        public void [AddPropertyValueAt(] string path, object at, [ShellObject] propertyValue )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// add-propertyvalue cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to add.
		        /// </param>
		        /// 
		        /// <param name="propertyValue">
		        /// The property to add the value on.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [AddPropertyValueAtDynamicParameters(] string path, object at, [ShellObject] propertyValue )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Clears the specified value of a property on the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item from which the property value should be cleared.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The property to clear the value from.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to clear.
		        /// </param>
		        /// 
		        public void [ClearPropertyValueAt(] string path, string propertyName, object at )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// clear-propertyvalue cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The property to clear the value from.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to clear.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [ClearPropertyValueAtDynamicParameters(] string path, string propertyName, object at )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Gets a value of a property from the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item from which the property value should be retrieved.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The property to get the value from.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to get.
		        /// </param>
		        /// 
		        public void [GetPropertyValueAt(] string path, string propertyName, object at )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// get-propertyvalue cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The property to get the value from.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to get.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [GetPropertyValueAtDynamicParameters(] string path, string propertyName, object at )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Sets a property value on the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item on which the property should be set.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to set.
		        /// </param>
		        /// 
		        /// <param name="propertyValue">
		        /// The property to set the value on.
		        /// </param>
		        /// 
		        public void [SetPropertyValueAt(] string path, object at, [ShellObject] propertyValue )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// set-propertyvalue cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to get.
		        /// </param>
		        /// 
		        /// <param name="propertyValue">
		        /// The property to set the value on.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [SetPropertyValueAtDynamicParameters(] string path, object at, [ShellObject] propertyValue )
		        {
		            return null;
		        }
	

		        /// <summary>
		        /// Removes the specified value of a property on the item specified by the path.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// The path to the item from which the property value should be removed.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The property to remove the value from.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property value to remove.
		        /// </param>
		        /// 
		        public void [RemovePropertyValueAt(] string path, string propertyName, object at )
		        {
		        }
	

		        /// <summary>
		        /// Gives the provider a chance to attach additional parameters to the
		        /// remove-propertyvalue cmdlet.
		        /// </summary>
		        /// 
		        /// <param name="path">
		        /// If the path was specified on the command line, this is the path
		        /// to the item to get the dynamic parameters for.
		        /// </param>
		        /// 
		        /// <param name="propertyName">
		        /// The property to remove the value from.
		        /// </param>
		        /// 
		        /// <param name="at">
		        /// The position of the property to remove.
		        /// </param>
		        /// 
		        /// <returns>
		        /// An object that has properties and fields decorated with
		        /// parsing attributes similar to a cmdlet class. Null can be
		        /// returned if no dynamic parameters are to be added.
		        /// </returns>
		        /// 
		        public object [RemovePropertyValueAtDynamicParameters(] string path, string propertyName, object at )
		        {
		            return null;
		        }
	

		        #endregion
		    }
		 }