iclusterstorage2

package
v0.0.0-...-4786ba3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 29, 2025 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// IClusterStorage2 interface identifier 12108a88-6858-4467-b92f-e6cf4568dfb6
	ClusterStorage2IID = &dcom.IID{Data1: 0x12108a88, Data2: 0x6858, Data3: 0x4467, Data4: []byte{0xb9, 0x2f, 0xe6, 0xcf, 0x45, 0x68, 0xdf, 0xb6}}
	// Syntax UUID
	ClusterStorage2SyntaxUUID = &uuid.UUID{TimeLow: 0x12108a88, TimeMid: 0x6858, TimeHiAndVersion: 0x4467, ClockSeqHiAndReserved: 0xb9, ClockSeqLow: 0x2f, Node: [6]uint8{0xe6, 0xcf, 0x45, 0x68, 0xdf, 0xb6}}
	// Syntax ID
	ClusterStorage2SyntaxV0_0 = &dcerpc.SyntaxID{IfUUID: ClusterStorage2SyntaxUUID, IfVersionMajor: 0, IfVersionMinor: 0}
)
View Source 
var (
	// import guard
	GoPackage = "dcom/csvp"
)

Functions

func ClusterStorage2ServerHandle 

func ClusterStorage2ServerHandle(ctx context.Context, o ClusterStorage2Server, opNum int, r ndr.Reader) (dcerpc.Operation, error)

func NewClusterStorage2ServerHandle 

func NewClusterStorage2ServerHandle(o ClusterStorage2Server) dcerpc.ServerHandle

func RegisterClusterStorage2Server 

func RegisterClusterStorage2Server(conn dcerpc.Conn, o ClusterStorage2Server, opts ...dcerpc.Option)

Types

type AttachRequest 

type AttachRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

AttachRequest structure represents the CprepDiskAttach operation request

func (*AttachRequest) MarshalNDR 

func (o *AttachRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*AttachRequest) UnmarshalNDR 

func (o *AttachRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type AttachResponse 

type AttachResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskAttach return value.
	Return int32 `idl:"name:Return" json:"return"`
}

AttachResponse structure represents the CprepDiskAttach operation response

func (*AttachResponse) MarshalNDR 

func (o *AttachResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*AttachResponse) UnmarshalNDR 

func (o *AttachResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type ClusterStorage2Client 

type ClusterStorage2Client interface {

	// IUnknown retrieval method.
	Unknown() iunknown.UnknownClient

	// The CprepDiskRawRead method reads information directly from a single 512 byte sector
	// on a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	|                RETURN                 |                                                                 |
	//	|              VALUE/CODE               |                           DESCRIPTION                           |
	//	|                                       |                                                                 |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                        |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                         |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x8007001E ERROR_READ_FAULT           | An attempt to read a buffer size larger than 512 was performed. |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                       |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 3.
	RawRead(context.Context, *RawReadRequest, ...dcerpc.CallOption) (*RawReadResponse, error)

	// The CprepDiskRawWrite method writes information directly to a single 512 byte sector
	// on a given disk.
	//
	// Return Values: A signed, 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+----------------------------------------------------------+
	//	|                RETURN                 |                                                          |
	//	|              VALUE/CODE               |                       DESCRIPTION                        |
	//	|                                       |                                                          |
	//	+---------------------------------------+----------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                 |
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                  |
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x8007001D ERROR_WRITE_FAULT          | The size of the passed buffer was larger than 512 bytes. |
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                |
	//	+---------------------------------------+----------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 4.
	RawWrite(context.Context, *RawWriteRequest, ...dcerpc.CallOption) (*RawWriteResponse, error)

	// The CprepPrepareNode method prepares the server in an implementation-specific way
	// to execute the other methods in the interface. It also informs the client about version
	// information.
	//
	// This method is called before any other.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+-------------------+--------------------------+
	//	|      RETURN       |                          |
	//	|    VALUE/CODE     |       DESCRIPTION        |
	//	|                   |                          |
	//	+-------------------+--------------------------+
	//	+-------------------+--------------------------+
	//	| 0x00000000 S_OK   | The call was successful. |
	//	+-------------------+--------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 5.
	PrepareNode(context.Context, *PrepareNodeRequest, ...dcerpc.CallOption) (*PrepareNodeResponse, error)

	// The CprepPrepareNodePhase2 method determines the number of disks accessible to the
	// system.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 6.
	PrepareNodePhase2(context.Context, *PrepareNodePhase2Request, ...dcerpc.CallOption) (*PrepareNodePhase2Response, error)

	// The CprepDiskGetProps method retrieves information about the configuration and status
	// of a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 7.
	GetProperties(context.Context, *GetPropertiesRequest, ...dcerpc.CallOption) (*GetPropertiesResponse, error)

	// The CprepDiskStopDefense method stops any implementation-specific method of maintaining
	// ownership of a disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                         |
	//	|              VALUE/CODE               |                               DESCRIPTION                               |
	//	|                                       |                                                                         |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                                 |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OwnedState is not equal to OwnedByThisServer. |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                               |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached.       |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 12.
	StopDefense(context.Context, *StopDefenseRequest, ...dcerpc.CallOption) (*StopDefenseResponse, error)

	// The CprepDiskOnline method begins the transition of a ClusPrepDisk.OnlineState to
	// Online and then waits for the transition to complete.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                         |
	//	|              VALUE/CODE               |                               DESCRIPTION                               |
	//	|                                       |                                                                         |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                                 |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OwnedState is not equal to OwnedByThisServer. |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                               |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 13.
	Online(context.Context, *OnlineRequest, ...dcerpc.CallOption) (*OnlineResponse, error)

	// The CprepDiskVerifyUnique method determines whether the same disk identifier is assigned
	// to more than one ClusPrepDisk in the attached state.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------+
	//	|                RETURN                 |                                                               |
	//	|              VALUE/CODE               |                          DESCRIPTION                          |
	//	|                                       |                                                               |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful and only one ClusPrepDisk has the ID. |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x800707DE ERROR_DUPLICATE_TAG        | There is more than one ClusPrepDisk with the given ID.        |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                       |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                     |
	//	+---------------------------------------+---------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 14.
	VerifyUnique(context.Context, *VerifyUniqueRequest, ...dcerpc.CallOption) (*VerifyUniqueResponse, error)

	// The CprepDiskWriteFileData method writes information to a file on a given partition
	// on a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x800703ED ERROR_UNRECOGNIZED_VOLUME  | The volume does not contain a file system.                          |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 17.
	WriteFileData(context.Context, *WriteFileDataRequest, ...dcerpc.CallOption) (*WriteFileDataResponse, error)

	// The CprepDiskVerifyFileData method verifies that the data in the file matches the
	// data passed to the method.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                                  |
	//	|              VALUE/CODE               |                                   DESCRIPTION                                    |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                         |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                             |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. The file     |
	//	|                                       | does not exist.                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x800703ED ERROR_UNRECOGNIZED_VOLUME  | The volume does not contain a file system.                                       |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                                        |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 18.
	VerifyFileData(context.Context, *VerifyFileDataRequest, ...dcerpc.CallOption) (*VerifyFileDataResponse, error)

	// The CprepDiskDeleteFile method deletes a file on a given partition on a given disk.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x800703ED ERROR_UNRECOGNIZED_VOLUME  | The volume does not contain a file system.                          |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 19.
	DeleteFile(context.Context, *DeleteFileRequest, ...dcerpc.CallOption) (*DeleteFileResponse, error)

	// The CprepDiskOffline method begins the transition of a ClusPrepDisk.OnlineState to
	// Not Online and then waits for the transition to complete.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------+
	//	|                RETURN                 |                                                               |
	//	|              VALUE/CODE               |                          DESCRIPTION                          |
	//	|                                       |                                                               |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                      |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                       |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OnlineState is not equal to Online. |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                     |
	//	+---------------------------------------+---------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 20.
	Offline(context.Context, *OfflineRequest, ...dcerpc.CallOption) (*OfflineResponse, error)

	// The CprepDiskGetUniqueIds method returns device ID data about the ClusPrepDisk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x8007007A ERROR_INSUFFICIENT_BUFFER  | pbData is not large enough.               |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070032 ERROR_NOT_SUPPORTED        | The disk does not support device ID data. |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 22.
	GetUniqueIDs(context.Context, *GetUniqueIDsRequest, ...dcerpc.CallOption) (*GetUniqueIDsResponse, error)

	// The CprepDiskAttach method offers implementations an opportunity to do disk-specific
	// setup before processing is done on a disk.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070490 ERROR_NOT_FOUND            | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 23.
	Attach(context.Context, *AttachRequest, ...dcerpc.CallOption) (*AttachResponse, error)

	// The CprepDiskPRArbitrate method establishes ownership of a ClusPrepDisk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 24.
	PRArbitrate(context.Context, *PRArbitrateRequest, ...dcerpc.CallOption) (*PRArbitrateResponse, error)

	// The CprepDiskPRRegister method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a REGISTER AND IGNORE EXISTING KEY action.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 25.
	PRRegister(context.Context, *PRRegisterRequest, ...dcerpc.CallOption) (*PRRegisterResponse, error)

	// The CprepDiskPRUnRegister method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a REGISTER AND IGNORE EXISTING KEY action with a key of
	// 0.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 26.
	PRUnregister(context.Context, *PRUnregisterRequest, ...dcerpc.CallOption) (*PRUnregisterResponse, error)

	// The CprepDiskPRReserve method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a RESERVE action.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 27.
	PRReserve(context.Context, *PRReserveRequest, ...dcerpc.CallOption) (*PRReserveResponse, error)

	// The CprepDiskPRRelease method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a RELEASE action.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 28.
	PRRelease(context.Context, *PRReleaseRequest, ...dcerpc.CallOption) (*PRReleaseResponse, error)

	// The CprepDiskDiskPartitionIsNtfs method determines whether the file system on a given
	// partition on a given disk is NTFS.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070022 ERROR_WRONG_DISK           | The partition on the disk has a file system other than NTFS.        |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState value is not equal to Online.          |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 29.
	DiskPartitionIsNTFS(context.Context, *DiskPartitionIsNTFSRequest, ...dcerpc.CallOption) (*DiskPartitionIsNTFSResponse, error)

	// The CprepDiskGetArbSectors method returns two sectors on the disk that can be used
	// as a "scratch pad" for raw reads/writes.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 30.
	GetArbSectors(context.Context, *GetArbSectorsRequest, ...dcerpc.CallOption) (*GetArbSectorsResponse, error)

	// The CprepDiskIsPRPresent method determines whether there are any PERSISTENT RESERVE
	// reservations on the disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 31.
	IsPRPresent(context.Context, *IsPRPresentRequest, ...dcerpc.CallOption) (*IsPRPresentResponse, error)

	// The CprepDiskPRPreempt method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a PREEMPT action.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 32.
	PRPreempt(context.Context, *PRPreemptRequest, ...dcerpc.CallOption) (*PRPreemptResponse, error)

	// The CprepDiskPRClear method performs a SCSI PERSISTENT RESERVE OUT command (see [SPC-3]
	// section 6.12) with a CLEAR action.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 33.
	PRClear(context.Context, *PRClearRequest, ...dcerpc.CallOption) (*PRClearResponse, error)

	// The CprepDiskIsOnline method reports whether the ClusPrepDisk, identified by the
	// DiskId parameter, has ClusPrepDisk.OnlineState equal to Online.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                          |
	//	|              VALUE/CODE               |                               DESCRIPTION                                |
	//	|                                       |                                                                          |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful and ClusPrepDisk.OnlineState is equal to Online. |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	| 0x80070015 ERROR_NOT_READY            | ClusPrepDisk.OnlineState is not equal to Online.                         |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                                |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 34.
	IsOnline(context.Context, *IsOnlineRequest, ...dcerpc.CallOption) (*IsOnlineResponse, error)

	// The CprepDiskSetOnline method starts the process of transitioning ClusPrepDisk.OnlineState
	// to the Online state.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                         |
	//	|              VALUE/CODE               |                               DESCRIPTION                               |
	//	|                                       |                                                                         |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OwnedState is not equal to OwnedByThisServer. |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                               |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 35.
	SetOnline(context.Context, *SetOnlineRequest, ...dcerpc.CallOption) (*SetOnlineResponse, error)

	// The CprepDiskGetFSName method returns the name of the file system on a given partition
	// on a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 36.
	GetFSName(context.Context, *GetFSNameRequest, ...dcerpc.CallOption) (*GetFSNameResponse, error)

	// The CprepDiskIsReadable method determines whether the disk data on the disk can be
	// successfully read.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 37.
	IsReadable(context.Context, *IsReadableRequest, ...dcerpc.CallOption) (*IsReadableResponse, error)

	// The CprepDiskGetDsms method returns the DSMs installed on the system.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+----------------------------+-----------------------------------------------------------+
	//	|           RETURN           |                                                           |
	//	|         VALUE/CODE         |                        DESCRIPTION                        |
	//	|                            |                                                           |
	//	+----------------------------+-----------------------------------------------------------+
	//	+----------------------------+-----------------------------------------------------------+
	//	| 0x00000000 S_OK            | The call was successful.                                  |
	//	+----------------------------+-----------------------------------------------------------+
	//	| 0x800700EA ERROR_MORE_DATA | RegisteredDsms was not large enough to hold all the data. |
	//	+----------------------------+-----------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 38.
	GetDSMs(context.Context, *GetDSMsRequest, ...dcerpc.CallOption) (*GetDSMsResponse, error)

	// AlterContext alters the client context.
	AlterContext(context.Context, ...dcerpc.Option) error

	// Conn returns the client connection (unsafe)
	Conn() dcerpc.Conn

	// IPID sets the object interface identifier.
	IPID(context.Context, *dcom.IPID) ClusterStorage2Client
}

IClusterStorage2 interface.

func NewClusterStorage2Client 

func NewClusterStorage2Client(ctx context.Context, cc dcerpc.Conn, opts ...dcerpc.Option) (ClusterStorage2Client, error)

type ClusterStorage2Server 

type ClusterStorage2Server interface {

	// IUnknown base class.
	iunknown.UnknownServer

	// The CprepDiskRawRead method reads information directly from a single 512 byte sector
	// on a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	|                RETURN                 |                                                                 |
	//	|              VALUE/CODE               |                           DESCRIPTION                           |
	//	|                                       |                                                                 |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                        |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                         |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x8007001E ERROR_READ_FAULT           | An attempt to read a buffer size larger than 512 was performed. |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                       |
	//	+---------------------------------------+-----------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 3.
	RawRead(context.Context, *RawReadRequest) (*RawReadResponse, error)

	// The CprepDiskRawWrite method writes information directly to a single 512 byte sector
	// on a given disk.
	//
	// Return Values: A signed, 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+----------------------------------------------------------+
	//	|                RETURN                 |                                                          |
	//	|              VALUE/CODE               |                       DESCRIPTION                        |
	//	|                                       |                                                          |
	//	+---------------------------------------+----------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                 |
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                  |
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x8007001D ERROR_WRITE_FAULT          | The size of the passed buffer was larger than 512 bytes. |
	//	+---------------------------------------+----------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                |
	//	+---------------------------------------+----------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 4.
	RawWrite(context.Context, *RawWriteRequest) (*RawWriteResponse, error)

	// The CprepPrepareNode method prepares the server in an implementation-specific way
	// to execute the other methods in the interface. It also informs the client about version
	// information.
	//
	// This method is called before any other.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+-------------------+--------------------------+
	//	|      RETURN       |                          |
	//	|    VALUE/CODE     |       DESCRIPTION        |
	//	|                   |                          |
	//	+-------------------+--------------------------+
	//	+-------------------+--------------------------+
	//	| 0x00000000 S_OK   | The call was successful. |
	//	+-------------------+--------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 5.
	PrepareNode(context.Context, *PrepareNodeRequest) (*PrepareNodeResponse, error)

	// The CprepPrepareNodePhase2 method determines the number of disks accessible to the
	// system.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 6.
	PrepareNodePhase2(context.Context, *PrepareNodePhase2Request) (*PrepareNodePhase2Response, error)

	// The CprepDiskGetProps method retrieves information about the configuration and status
	// of a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 7.
	GetProperties(context.Context, *GetPropertiesRequest) (*GetPropertiesResponse, error)

	// The CprepDiskStopDefense method stops any implementation-specific method of maintaining
	// ownership of a disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                         |
	//	|              VALUE/CODE               |                               DESCRIPTION                               |
	//	|                                       |                                                                         |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                                 |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OwnedState is not equal to OwnedByThisServer. |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                               |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached.       |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 12.
	StopDefense(context.Context, *StopDefenseRequest) (*StopDefenseResponse, error)

	// The CprepDiskOnline method begins the transition of a ClusPrepDisk.OnlineState to
	// Online and then waits for the transition to complete.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                         |
	//	|              VALUE/CODE               |                               DESCRIPTION                               |
	//	|                                       |                                                                         |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                                 |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OwnedState is not equal to OwnedByThisServer. |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                               |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 13.
	Online(context.Context, *OnlineRequest) (*OnlineResponse, error)

	// The CprepDiskVerifyUnique method determines whether the same disk identifier is assigned
	// to more than one ClusPrepDisk in the attached state.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------+
	//	|                RETURN                 |                                                               |
	//	|              VALUE/CODE               |                          DESCRIPTION                          |
	//	|                                       |                                                               |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful and only one ClusPrepDisk has the ID. |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x800707DE ERROR_DUPLICATE_TAG        | There is more than one ClusPrepDisk with the given ID.        |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                       |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                     |
	//	+---------------------------------------+---------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 14.
	VerifyUnique(context.Context, *VerifyUniqueRequest) (*VerifyUniqueResponse, error)

	// The CprepDiskWriteFileData method writes information to a file on a given partition
	// on a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x800703ED ERROR_UNRECOGNIZED_VOLUME  | The volume does not contain a file system.                          |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 17.
	WriteFileData(context.Context, *WriteFileDataRequest) (*WriteFileDataResponse, error)

	// The CprepDiskVerifyFileData method verifies that the data in the file matches the
	// data passed to the method.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                                  |
	//	|              VALUE/CODE               |                                   DESCRIPTION                                    |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                         |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                             |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. The file     |
	//	|                                       | does not exist.                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x800703ED ERROR_UNRECOGNIZED_VOLUME  | The volume does not contain a file system.                                       |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                                        |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 18.
	VerifyFileData(context.Context, *VerifyFileDataRequest) (*VerifyFileDataResponse, error)

	// The CprepDiskDeleteFile method deletes a file on a given partition on a given disk.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x800703ED ERROR_UNRECOGNIZED_VOLUME  | The volume does not contain a file system.                          |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 19.
	DeleteFile(context.Context, *DeleteFileRequest) (*DeleteFileResponse, error)

	// The CprepDiskOffline method begins the transition of a ClusPrepDisk.OnlineState to
	// Not Online and then waits for the transition to complete.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------+
	//	|                RETURN                 |                                                               |
	//	|              VALUE/CODE               |                          DESCRIPTION                          |
	//	|                                       |                                                               |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                      |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                       |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OnlineState is not equal to Online. |
	//	+---------------------------------------+---------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                     |
	//	+---------------------------------------+---------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 20.
	Offline(context.Context, *OfflineRequest) (*OfflineResponse, error)

	// The CprepDiskGetUniqueIds method returns device ID data about the ClusPrepDisk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x8007007A ERROR_INSUFFICIENT_BUFFER  | pbData is not large enough.               |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070032 ERROR_NOT_SUPPORTED        | The disk does not support device ID data. |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 22.
	GetUniqueIDs(context.Context, *GetUniqueIDsRequest) (*GetUniqueIDsResponse, error)

	// The CprepDiskAttach method offers implementations an opportunity to do disk-specific
	// setup before processing is done on a disk.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070490 ERROR_NOT_FOUND            | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 23.
	Attach(context.Context, *AttachRequest) (*AttachResponse, error)

	// The CprepDiskPRArbitrate method establishes ownership of a ClusPrepDisk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 24.
	PRArbitrate(context.Context, *PRArbitrateRequest) (*PRArbitrateResponse, error)

	// The CprepDiskPRRegister method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a REGISTER AND IGNORE EXISTING KEY action.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 25.
	PRRegister(context.Context, *PRRegisterRequest) (*PRRegisterResponse, error)

	// The CprepDiskPRUnRegister method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a REGISTER AND IGNORE EXISTING KEY action with a key of
	// 0.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 26.
	PRUnregister(context.Context, *PRUnregisterRequest) (*PRUnregisterResponse, error)

	// The CprepDiskPRReserve method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a RESERVE action.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 27.
	PRReserve(context.Context, *PRReserveRequest) (*PRReserveResponse, error)

	// The CprepDiskPRRelease method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a RELEASE action.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	|                RETURN                 |                                                                   |
	//	|              VALUE/CODE               |                            DESCRIPTION                            |
	//	|                                       |                                                                   |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                          |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                                           |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                         |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.AttachedState is not equal to Attached. |
	//	+---------------------------------------+-------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 28.
	PRRelease(context.Context, *PRReleaseRequest) (*PRReleaseResponse, error)

	// The CprepDiskDiskPartitionIsNtfs method determines whether the file system on a given
	// partition on a given disk is NTFS.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070022 ERROR_WRONG_DISK           | The partition on the disk has a file system other than NTFS.        |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState value is not equal to Online.          |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 29.
	DiskPartitionIsNTFS(context.Context, *DiskPartitionIsNTFSRequest) (*DiskPartitionIsNTFSResponse, error)

	// The CprepDiskGetArbSectors method returns two sectors on the disk that can be used
	// as a "scratch pad" for raw reads/writes.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 30.
	GetArbSectors(context.Context, *GetArbSectorsRequest) (*GetArbSectorsResponse, error)

	// The CprepDiskIsPRPresent method determines whether there are any PERSISTENT RESERVE
	// reservations on the disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 31.
	IsPRPresent(context.Context, *IsPRPresentRequest) (*IsPRPresentResponse, error)

	// The CprepDiskPRPreempt method performs a SCSI PERSISTENT RESERVE OUT command (see
	// [SPC-3] section 6.12) with a PREEMPT action.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 32.
	PRPreempt(context.Context, *PRPreemptRequest) (*PRPreemptResponse, error)

	// The CprepDiskPRClear method performs a SCSI PERSISTENT RESERVE OUT command (see [SPC-3]
	// section 6.12) with a CLEAR action.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 33.
	PRClear(context.Context, *PRClearRequest) (*PRClearResponse, error)

	// The CprepDiskIsOnline method reports whether the ClusPrepDisk, identified by the
	// DiskId parameter, has ClusPrepDisk.OnlineState equal to Online.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                          |
	//	|              VALUE/CODE               |                               DESCRIPTION                                |
	//	|                                       |                                                                          |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful and ClusPrepDisk.OnlineState is equal to Online. |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	| 0x80070015 ERROR_NOT_READY            | ClusPrepDisk.OnlineState is not equal to Online.                         |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                                |
	//	+---------------------------------------+--------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 34.
	IsOnline(context.Context, *IsOnlineRequest) (*IsOnlineResponse, error)

	// The CprepDiskSetOnline method starts the process of transitioning ClusPrepDisk.OnlineState
	// to the Online state.
	//
	// Return Values:  A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	|                RETURN                 |                                                                         |
	//	|              VALUE/CODE               |                               DESCRIPTION                               |
	//	|                                       |                                                                         |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                                |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The value of ClusPrepDisk.OwnedState is not equal to OwnedByThisServer. |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                               |
	//	+---------------------------------------+-------------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 35.
	SetOnline(context.Context, *SetOnlineRequest) (*SetOnlineResponse, error)

	// The CprepDiskGetFSName method returns the name of the file system on a given partition
	// on a given disk.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	|                RETURN                 |                                                                     |
	//	|              VALUE/CODE               |                             DESCRIPTION                             |
	//	|                                       |                                                                     |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                                            |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found or ulPartition cannot be mapped to a volume. |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x8007139F ERROR_INVALID_STATE        | The ClusPrepDisk.OnlineState is not equal to Online.                |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online.                           |
	//	+---------------------------------------+---------------------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 36.
	GetFSName(context.Context, *GetFSNameRequest) (*GetFSNameResponse, error)

	// The CprepDiskIsReadable method determines whether the disk data on the disk can be
	// successfully read.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+---------------------------------------+-------------------------------------------+
	//	|                RETURN                 |                                           |
	//	|              VALUE/CODE               |                DESCRIPTION                |
	//	|                                       |                                           |
	//	+---------------------------------------+-------------------------------------------+
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x00000000 S_OK                       | The call was successful.                  |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070002 ERROR_FILE_NOT_FOUND       | The disk was not found.                   |
	//	+---------------------------------------+-------------------------------------------+
	//	| 0x80070548 ERROR_INVALID_SERVER_STATE | The server's Prepare State is not Online. |
	//	+---------------------------------------+-------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 37.
	IsReadable(context.Context, *IsReadableRequest) (*IsReadableResponse, error)

	// The CprepDiskGetDsms method returns the DSMs installed on the system.
	//
	// Return Values: A signed 32-bit value that indicates return status. If the method
	// returns a negative value, it has failed. Zero or positive values indicate success,
	// with the lower 16 bits in positive nonzero values containing warnings or flags defined
	// in the method implementation. For more information about Win32 error codes and HRESULT
	// values, see [MS-ERREF] sections 2.2 and 2.1.
	//
	//	+----------------------------+-----------------------------------------------------------+
	//	|           RETURN           |                                                           |
	//	|         VALUE/CODE         |                        DESCRIPTION                        |
	//	|                            |                                                           |
	//	+----------------------------+-----------------------------------------------------------+
	//	+----------------------------+-----------------------------------------------------------+
	//	| 0x00000000 S_OK            | The call was successful.                                  |
	//	+----------------------------+-----------------------------------------------------------+
	//	| 0x800700EA ERROR_MORE_DATA | RegisteredDsms was not large enough to hold all the data. |
	//	+----------------------------+-----------------------------------------------------------+
	//
	// Exceptions Thrown: No exceptions are thrown beyond those thrown by the underlying
	// RPC protocol [MS-RPCE].
	//
	// The opnum field value for this method is 38.
	GetDSMs(context.Context, *GetDSMsRequest) (*GetDSMsResponse, error)
}

IClusterStorage2 server interface.

type DeleteFileRequest 

type DeleteFileRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId:  The identifier of the ClusPrepDisk representing the disk that holds the
	// file to be deleted.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// ulPartition: The partition number of the partition associated with the volume on
	// the disk that holds the file to be deleted.
	Partition uint32 `idl:"name:ulPartition" json:"partition"`
	// FileName:  The path and name of the file to delete.
	FileName string `idl:"name:FileName;string" json:"file_name"`
}

DeleteFileRequest structure represents the CprepDiskDeleteFile operation request

func (*DeleteFileRequest) MarshalNDR 

func (o *DeleteFileRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DeleteFileRequest) UnmarshalNDR 

func (o *DeleteFileRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type DeleteFileResponse 

type DeleteFileResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskDeleteFile return value.
	Return int32 `idl:"name:Return" json:"return"`
}

DeleteFileResponse structure represents the CprepDiskDeleteFile operation response

func (*DeleteFileResponse) MarshalNDR 

func (o *DeleteFileResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DeleteFileResponse) UnmarshalNDR 

func (o *DeleteFileResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type DiskPartitionIsNTFSRequest 

type DiskPartitionIsNTFSRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// ulPartition: The partition number of the partition associated with the volume to
	// query for file system information.
	Partition uint32 `idl:"name:ulPartition" json:"partition"`
}

DiskPartitionIsNTFSRequest structure represents the CprepDiskDiskPartitionIsNtfs operation request

func (*DiskPartitionIsNTFSRequest) MarshalNDR 

func (o *DiskPartitionIsNTFSRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DiskPartitionIsNTFSRequest) UnmarshalNDR 

func (o *DiskPartitionIsNTFSRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type DiskPartitionIsNTFSResponse 

type DiskPartitionIsNTFSResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskDiskPartitionIsNtfs return value.
	Return int32 `idl:"name:Return" json:"return"`
}

DiskPartitionIsNTFSResponse structure represents the CprepDiskDiskPartitionIsNtfs operation response

func (*DiskPartitionIsNTFSResponse) MarshalNDR 

func (o *DiskPartitionIsNTFSResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DiskPartitionIsNTFSResponse) UnmarshalNDR 

func (o *DiskPartitionIsNTFSResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetArbSectorsRequest 

type GetArbSectorsRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

GetArbSectorsRequest structure represents the CprepDiskGetArbSectors operation request

func (*GetArbSectorsRequest) MarshalNDR 

func (o *GetArbSectorsRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetArbSectorsRequest) UnmarshalNDR 

func (o *GetArbSectorsRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetArbSectorsResponse 

type GetArbSectorsResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// SectorX: The first sector number that is available.
	SectorX uint32 `idl:"name:SectorX" json:"sector_x"`
	// SectorY: The second sector number that is available.
	SectorY uint32 `idl:"name:SectorY" json:"sector_y"`
	// Return: The CprepDiskGetArbSectors return value.
	Return int32 `idl:"name:Return" json:"return"`
}

GetArbSectorsResponse structure represents the CprepDiskGetArbSectors operation response

func (*GetArbSectorsResponse) MarshalNDR 

func (o *GetArbSectorsResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetArbSectorsResponse) UnmarshalNDR 

func (o *GetArbSectorsResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetDSMsRequest 

type GetDSMsRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// Size: The size, in bytes, of the RegisteredDsms parameter.
	Size uint32 `idl:"name:Size" json:"size"`
}

GetDSMsRequest structure represents the CprepDiskGetDsms operation request

func (*GetDSMsRequest) MarshalNDR 

func (o *GetDSMsRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetDSMsRequest) UnmarshalNDR 

func (o *GetDSMsRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetDSMsResponse 

type GetDSMsResponse struct {
	// XXX: Size is an implicit input depedency for output parameters
	Size uint32 `idl:"name:Size" json:"size"`

	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That            *dcom.ORPCThat `idl:"name:That" json:"that"`
	ResgisteredDSMs uint32         `idl:"name:pResgisteredDsms" json:"resgistered_dsms"`
	// RegisteredDsms: The buffer that holds the DSM data. The format of the buffer is a
	// REGISTERED_DSMS structure.
	RegisteredDSMs []byte `idl:"name:RegisteredDsms;size_is:(Size);length_is:(pResgisteredDsms)" json:"registered_dsms"`
	// Return: The CprepDiskGetDsms return value.
	Return int32 `idl:"name:Return" json:"return"`
}

GetDSMsResponse structure represents the CprepDiskGetDsms operation response

func (*GetDSMsResponse) MarshalNDR 

func (o *GetDSMsResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetDSMsResponse) UnmarshalNDR 

func (o *GetDSMsResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetFSNameRequest 

type GetFSNameRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// Partition: The partition number of the partition associated with the volume to query
	// for file system information.
	Partition uint32 `idl:"name:Partition" json:"partition"`
}

GetFSNameRequest structure represents the CprepDiskGetFSName operation request

func (*GetFSNameRequest) MarshalNDR 

func (o *GetFSNameRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetFSNameRequest) UnmarshalNDR 

func (o *GetFSNameRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetFSNameResponse 

type GetFSNameResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// FsName: A null-terminated output string that contains the name of the file system.
	// The value MUST be "NTFS" if the partition has the NTFS file system. The value MUST
	// be "FAT" for the file allocation table (FAT) file system. No file system and unrecognized
	// file systems MUST be "RAW". Other values can be used for file systems not specified
	// here.
	//
	//	+--------+-----------------------------------------------------------+
	//	|        |                                                           |
	//	| VALUE  |                          MEANING                          |
	//	|        |                                                           |
	//	+--------+-----------------------------------------------------------+
	//	+--------+-----------------------------------------------------------+
	//	| "NTFS" | The partition file system is NTFS.                        |
	//	+--------+-----------------------------------------------------------+
	//	| "FAT"  | The partition file system is FAT.                         |
	//	+--------+-----------------------------------------------------------+
	//	| "RAW"  | There is no partition file system, or it is unrecognized. |
	//	+--------+-----------------------------------------------------------+
	FSName []uint16 `idl:"name:FsName" json:"fs_name"`
	// Return: The CprepDiskGetFSName return value.
	Return int32 `idl:"name:Return" json:"return"`
}

GetFSNameResponse structure represents the CprepDiskGetFSName operation response

func (*GetFSNameResponse) MarshalNDR 

func (o *GetFSNameResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetFSNameResponse) UnmarshalNDR 

func (o *GetFSNameResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetPropertiesRequest 

type GetPropertiesRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk for which to get the disk properties.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

GetPropertiesRequest structure represents the CprepDiskGetProps operation request

func (*GetPropertiesRequest) MarshalNDR 

func (o *GetPropertiesRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetPropertiesRequest) UnmarshalNDR 

func (o *GetPropertiesRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetPropertiesResponse 

type GetPropertiesResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// DiskProps: The properties of the selected ClusPrepDisk.
	DiskProperties *csvp.DiskProperties `idl:"name:DiskProps" json:"disk_properties"`
	// Return: The CprepDiskGetProps return value.
	Return int32 `idl:"name:Return" json:"return"`
}

GetPropertiesResponse structure represents the CprepDiskGetProps operation response

func (*GetPropertiesResponse) MarshalNDR 

func (o *GetPropertiesResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetPropertiesResponse) UnmarshalNDR 

func (o *GetPropertiesResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetUniqueIDsRequest 

type GetUniqueIDsRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier representing the ClusPrepDisk for which to retrieve the device
	// ID data.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// cbData: The size, in bytes, of the pbData buffer passed to the server.
	DataLength uint32 `idl:"name:cbData" json:"data_length"`
}

GetUniqueIDsRequest structure represents the CprepDiskGetUniqueIds operation request

func (*GetUniqueIDsRequest) MarshalNDR 

func (o *GetUniqueIDsRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetUniqueIDsRequest) UnmarshalNDR 

func (o *GetUniqueIDsRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type GetUniqueIDsResponse 

type GetUniqueIDsResponse struct {
	// XXX: cbData is an implicit input depedency for output parameters
	DataLength uint32 `idl:"name:cbData" json:"data_length"`

	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// pbData: The output buffer for the device ID data.
	Data []byte `idl:"name:pbData;size_is:(cbData);length_is:(pcbDataOut)" json:"data"`
	// pcbDataOut: The size, in bytes, of the amount of data written to pbData on a successful
	// return.
	DataOutLength uint32 `idl:"name:pcbDataOut" json:"data_out_length"`
	// pcbNeeded: If ERROR_INSUFFICIENT_BUFFER is returned, then this parameter contains
	// the size, in bytes, of the buffer required for a successful call.
	NeededLength uint32 `idl:"name:pcbNeeded" json:"needed_length"`
	// Return: The CprepDiskGetUniqueIds return value.
	Return int32 `idl:"name:Return" json:"return"`
}

GetUniqueIDsResponse structure represents the CprepDiskGetUniqueIds operation response

func (*GetUniqueIDsResponse) MarshalNDR 

func (o *GetUniqueIDsResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetUniqueIDsResponse) UnmarshalNDR 

func (o *GetUniqueIDsResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type IsOnlineRequest 

type IsOnlineRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier representing the ClusPrepDisk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

IsOnlineRequest structure represents the CprepDiskIsOnline operation request

func (*IsOnlineRequest) MarshalNDR 

func (o *IsOnlineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IsOnlineRequest) UnmarshalNDR 

func (o *IsOnlineRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type IsOnlineResponse 

type IsOnlineResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskIsOnline return value.
	Return int32 `idl:"name:Return" json:"return"`
}

IsOnlineResponse structure represents the CprepDiskIsOnline operation response

func (*IsOnlineResponse) MarshalNDR 

func (o *IsOnlineResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IsOnlineResponse) UnmarshalNDR 

func (o *IsOnlineResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type IsPRPresentRequest 

type IsPRPresentRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

IsPRPresentRequest structure represents the CprepDiskIsPRPresent operation request

func (*IsPRPresentRequest) MarshalNDR 

func (o *IsPRPresentRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IsPRPresentRequest) UnmarshalNDR 

func (o *IsPRPresentRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type IsPRPresentResponse 

type IsPRPresentResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Present: MUST be 0x00000000 if no reserves are present. MUST be 0x00000001 or 0x00000002
	// if reserves are present.
	//
	//	+------------+--------------------------------------------------------------------------+
	//	|            |                                                                          |
	//	|   VALUE    |                                 MEANING                                  |
	//	|            |                                                                          |
	//	+------------+--------------------------------------------------------------------------+
	//	+------------+--------------------------------------------------------------------------+
	//	| 0x00000000 | No reserves are present.                                                 |
	//	+------------+--------------------------------------------------------------------------+
	//	| 0x00000001 | A persistent reservation is present and is not held by the local server. |
	//	+------------+--------------------------------------------------------------------------+
	//	| 0x00000002 | A persistent reservation is present and is held by the local server.<15> |
	//	+------------+--------------------------------------------------------------------------+
	Present uint32 `idl:"name:Present" json:"present"`
	// Return: The CprepDiskIsPRPresent return value.
	Return int32 `idl:"name:Return" json:"return"`
}

IsPRPresentResponse structure represents the CprepDiskIsPRPresent operation response

func (*IsPRPresentResponse) MarshalNDR 

func (o *IsPRPresentResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IsPRPresentResponse) UnmarshalNDR 

func (o *IsPRPresentResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type IsReadableRequest 

type IsReadableRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

IsReadableRequest structure represents the CprepDiskIsReadable operation request

func (*IsReadableRequest) MarshalNDR 

func (o *IsReadableRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IsReadableRequest) UnmarshalNDR 

func (o *IsReadableRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type IsReadableResponse 

type IsReadableResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskIsReadable return value.
	Return int32 `idl:"name:Return" json:"return"`
}

IsReadableResponse structure represents the CprepDiskIsReadable operation response

func (*IsReadableResponse) MarshalNDR 

func (o *IsReadableResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IsReadableResponse) UnmarshalNDR 

func (o *IsReadableResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OfflineRequest 

type OfflineRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk whose associated
	// volumes will become Offline.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

OfflineRequest structure represents the CprepDiskOffline operation request

func (*OfflineRequest) MarshalNDR 

func (o *OfflineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OfflineRequest) UnmarshalNDR 

func (o *OfflineRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OfflineResponse 

type OfflineResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskOffline return value.
	Return int32 `idl:"name:Return" json:"return"`
}

OfflineResponse structure represents the CprepDiskOffline operation response

func (*OfflineResponse) MarshalNDR 

func (o *OfflineResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OfflineResponse) UnmarshalNDR 

func (o *OfflineResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OnlineRequest 

type OnlineRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk whose associated
	// volumes will become online.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

OnlineRequest structure represents the CprepDiskOnline operation request

func (*OnlineRequest) MarshalNDR 

func (o *OnlineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OnlineRequest) UnmarshalNDR 

func (o *OnlineRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type OnlineResponse 

type OnlineResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// MaxPartitionNumber:  The number of partitions on the disk.
	MaxPartitionNumber uint32 `idl:"name:MaxPartitionNumber" json:"max_partition_number"`
	// Return: The CprepDiskOnline return value.
	Return int32 `idl:"name:Return" json:"return"`
}

OnlineResponse structure represents the CprepDiskOnline operation response

func (*OnlineResponse) MarshalNDR 

func (o *OnlineResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*OnlineResponse) UnmarshalNDR 

func (o *OnlineResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRArbitrateRequest 

type PRArbitrateRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRArbitrateRequest structure represents the CprepDiskPRArbitrate operation request

func (*PRArbitrateRequest) MarshalNDR 

func (o *PRArbitrateRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRArbitrateRequest) UnmarshalNDR 

func (o *PRArbitrateRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRArbitrateResponse 

type PRArbitrateResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRArbitrate return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRArbitrateResponse structure represents the CprepDiskPRArbitrate operation response

func (*PRArbitrateResponse) MarshalNDR 

func (o *PRArbitrateResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRArbitrateResponse) UnmarshalNDR 

func (o *PRArbitrateResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRClearRequest 

type PRClearRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRClearRequest structure represents the CprepDiskPRClear operation request

func (*PRClearRequest) MarshalNDR 

func (o *PRClearRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRClearRequest) UnmarshalNDR 

func (o *PRClearRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRClearResponse 

type PRClearResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRClear return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRClearResponse structure represents the CprepDiskPRClear operation response

func (*PRClearResponse) MarshalNDR 

func (o *PRClearResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRClearResponse) UnmarshalNDR 

func (o *PRClearResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRPreemptRequest 

type PRPreemptRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRPreemptRequest structure represents the CprepDiskPRPreempt operation request

func (*PRPreemptRequest) MarshalNDR 

func (o *PRPreemptRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRPreemptRequest) UnmarshalNDR 

func (o *PRPreemptRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRPreemptResponse 

type PRPreemptResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRPreempt return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRPreemptResponse structure represents the CprepDiskPRPreempt operation response

func (*PRPreemptResponse) MarshalNDR 

func (o *PRPreemptResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRPreemptResponse) UnmarshalNDR 

func (o *PRPreemptResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRRegisterRequest 

type PRRegisterRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRRegisterRequest structure represents the CprepDiskPRRegister operation request

func (*PRRegisterRequest) MarshalNDR 

func (o *PRRegisterRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRRegisterRequest) UnmarshalNDR 

func (o *PRRegisterRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRRegisterResponse 

type PRRegisterResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRRegister return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRRegisterResponse structure represents the CprepDiskPRRegister operation response

func (*PRRegisterResponse) MarshalNDR 

func (o *PRRegisterResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRRegisterResponse) UnmarshalNDR 

func (o *PRRegisterResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRReleaseRequest 

type PRReleaseRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRReleaseRequest structure represents the CprepDiskPRRelease operation request

func (*PRReleaseRequest) MarshalNDR 

func (o *PRReleaseRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRReleaseRequest) UnmarshalNDR 

func (o *PRReleaseRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRReleaseResponse 

type PRReleaseResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRRelease return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRReleaseResponse structure represents the CprepDiskPRRelease operation response

func (*PRReleaseResponse) MarshalNDR 

func (o *PRReleaseResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRReleaseResponse) UnmarshalNDR 

func (o *PRReleaseResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRReserveRequest 

type PRReserveRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRReserveRequest structure represents the CprepDiskPRReserve operation request

func (*PRReserveRequest) MarshalNDR 

func (o *PRReserveRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRReserveRequest) UnmarshalNDR 

func (o *PRReserveRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRReserveResponse 

type PRReserveResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRReserve return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRReserveResponse structure represents the CprepDiskPRReserve operation response

func (*PRReserveResponse) MarshalNDR 

func (o *PRReserveResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRReserveResponse) UnmarshalNDR 

func (o *PRReserveResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRUnregisterRequest 

type PRUnregisterRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

PRUnregisterRequest structure represents the CprepDiskPRUnRegister operation request

func (*PRUnregisterRequest) MarshalNDR 

func (o *PRUnregisterRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRUnregisterRequest) UnmarshalNDR 

func (o *PRUnregisterRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PRUnregisterResponse 

type PRUnregisterResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskPRUnRegister return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PRUnregisterResponse structure represents the CprepDiskPRUnRegister operation response

func (*PRUnregisterResponse) MarshalNDR 

func (o *PRUnregisterResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PRUnregisterResponse) UnmarshalNDR 

func (o *PRUnregisterResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PrepareNodePhase2Request 

type PrepareNodePhase2Request struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// Flags:   The client SHOULD<14> pass in one of the following values:
	//
	//	+------------------------------------------+-------------------------------------------------------------------+
	//	|                                          |                                                                   |
	//	|                  VALUE                   |                              MEANING                              |
	//	|                                          |                                                                   |
	//	+------------------------------------------+-------------------------------------------------------------------+
	//	+------------------------------------------+-------------------------------------------------------------------+
	//	| ForceOfflineNonClusteredDisks 0x00000001 | When set, the spaces on the nonclustered pool are force detached. |
	//	+------------------------------------------+-------------------------------------------------------------------+
	//	| SkipNonClusteredPools 0x00000002         | When set, the nonclustered pools are skipped.                     |
	//	+------------------------------------------+-------------------------------------------------------------------+
	Flags uint32 `idl:"name:Flags" json:"flags"`
}

PrepareNodePhase2Request structure represents the CprepPrepareNodePhase2 operation request

func (*PrepareNodePhase2Request) MarshalNDR 

func (o *PrepareNodePhase2Request) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PrepareNodePhase2Request) UnmarshalNDR 

func (o *PrepareNodePhase2Request) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PrepareNodePhase2Response 

type PrepareNodePhase2Response struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// pulNumDisks: The number of disks accessible to the system.
	DisksLength uint32 `idl:"name:pulNumDisks" json:"disks_length"`
	// Return: The CprepPrepareNodePhase2 return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PrepareNodePhase2Response structure represents the CprepPrepareNodePhase2 operation response

func (*PrepareNodePhase2Response) MarshalNDR 

func (o *PrepareNodePhase2Response) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PrepareNodePhase2Response) UnmarshalNDR 

func (o *PrepareNodePhase2Response) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PrepareNodeRequest 

type PrepareNodeRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
}

PrepareNodeRequest structure represents the CprepPrepareNode operation request

func (*PrepareNodeRequest) MarshalNDR 

func (o *PrepareNodeRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PrepareNodeRequest) UnmarshalNDR 

func (o *PrepareNodeRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type PrepareNodeResponse 

type PrepareNodeResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// pulMajorVersion: The server MUST set this to the operating system major version.
	MajorVersion uint32 `idl:"name:pulMajorVersion" json:"major_version"`
	// pulMinorVersion: The server MUST set this to the operating system minor version.
	MinorVersion uint32 `idl:"name:pulMinorVersion" json:"minor_version"`
	// pdwCPrepVersion: The client MUST ignore this value.
	ClusterPrepareVersion uint32 `idl:"name:pdwCPrepVersion" json:"cluster_prepare_version"`
	// Return: The CprepPrepareNode return value.
	Return int32 `idl:"name:Return" json:"return"`
}

PrepareNodeResponse structure represents the CprepPrepareNode operation response

func (*PrepareNodeResponse) MarshalNDR 

func (o *PrepareNodeResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PrepareNodeResponse) UnmarshalNDR 

func (o *PrepareNodeResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type RawReadRequest 

type RawReadRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk that holds the sector
	// from which to read.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// ulSector: The sector number to read from.
	Sector uint32 `idl:"name:ulSector" json:"sector"`
	// cbData: The size, in bytes, of the buffer pbData.
	DataLength uint32 `idl:"name:cbData" json:"data_length"`
}

RawReadRequest structure represents the CprepDiskRawRead operation request

func (*RawReadRequest) MarshalNDR 

func (o *RawReadRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RawReadRequest) UnmarshalNDR 

func (o *RawReadRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type RawReadResponse 

type RawReadResponse struct {
	// XXX: cbData is an implicit input depedency for output parameters
	DataLength uint32 `idl:"name:cbData" json:"data_length"`

	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// pbData: The data to read from the disk.
	Data []byte `idl:"name:pbData;size_is:(cbData);length_is:(pcbDataRead)" json:"data"`
	// pcbDataRead: On successful completion, the server MUST set this to cbData. Otherwise
	// the client MUST ignore this value.
	DataReadLength uint32 `idl:"name:pcbDataRead" json:"data_read_length"`
	// ulLatency: The time, in milliseconds, that the read took to be performed.
	Latency uint32 `idl:"name:ulLatency" json:"latency"`
	// Return: The CprepDiskRawRead return value.
	Return int32 `idl:"name:Return" json:"return"`
}

RawReadResponse structure represents the CprepDiskRawRead operation response

func (*RawReadResponse) MarshalNDR 

func (o *RawReadResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RawReadResponse) UnmarshalNDR 

func (o *RawReadResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type RawWriteRequest 

type RawWriteRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk that holds the sector
	// to which to write.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// ulSector: The sector number to write to.
	Sector uint32 `idl:"name:ulSector" json:"sector"`
	// cbData: The size, in bytes of the buffer pbData.
	DataLength uint32 `idl:"name:cbData" json:"data_length"`
	// pbData: The data to write to the disk.
	Data []byte `idl:"name:pbData;size_is:(cbData)" json:"data"`
}

RawWriteRequest structure represents the CprepDiskRawWrite operation request

func (*RawWriteRequest) MarshalNDR 

func (o *RawWriteRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RawWriteRequest) UnmarshalNDR 

func (o *RawWriteRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type RawWriteResponse 

type RawWriteResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// pcbDataWritten: If the CprepDiskRawWrite method is successful, the server MUST set
	// this value to 512. If an error occurs, the server MUST set pcbDataWritten to zero.
	DataWrittenLength uint32 `idl:"name:pcbDataWritten" json:"data_written_length"`
	// ulLatency: The time, in milliseconds, that the write took to be performed.
	Latency uint32 `idl:"name:ulLatency" json:"latency"`
	// Return: The CprepDiskRawWrite return value.
	Return int32 `idl:"name:Return" json:"return"`
}

RawWriteResponse structure represents the CprepDiskRawWrite operation response

func (*RawWriteResponse) MarshalNDR 

func (o *RawWriteResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RawWriteResponse) UnmarshalNDR 

func (o *RawWriteResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type SetOnlineRequest 

type SetOnlineRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier representing the ClusPrepDisk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

SetOnlineRequest structure represents the CprepDiskSetOnline operation request

func (*SetOnlineRequest) MarshalNDR 

func (o *SetOnlineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SetOnlineRequest) UnmarshalNDR 

func (o *SetOnlineRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type SetOnlineResponse 

type SetOnlineResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskSetOnline return value.
	Return int32 `idl:"name:Return" json:"return"`
}

SetOnlineResponse structure represents the CprepDiskSetOnline operation response

func (*SetOnlineResponse) MarshalNDR 

func (o *SetOnlineResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SetOnlineResponse) UnmarshalNDR 

func (o *SetOnlineResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type StopDefenseRequest 

type StopDefenseRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

StopDefenseRequest structure represents the CprepDiskStopDefense operation request

func (*StopDefenseRequest) MarshalNDR 

func (o *StopDefenseRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StopDefenseRequest) UnmarshalNDR 

func (o *StopDefenseRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type StopDefenseResponse 

type StopDefenseResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskStopDefense return value.
	Return int32 `idl:"name:Return" json:"return"`
}

StopDefenseResponse structure represents the CprepDiskStopDefense operation response

func (*StopDefenseResponse) MarshalNDR 

func (o *StopDefenseResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StopDefenseResponse) UnmarshalNDR 

func (o *StopDefenseResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type UnimplementedClusterStorage2Server 

type UnimplementedClusterStorage2Server struct {
	iunknown.UnimplementedUnknownServer
}

Unimplemented IClusterStorage2

func (UnimplementedClusterStorage2Server) Attach 

func (UnimplementedClusterStorage2Server) Attach(context.Context, *AttachRequest) (*AttachResponse, error)

func (UnimplementedClusterStorage2Server) DeleteFile 

func (UnimplementedClusterStorage2Server) DeleteFile(context.Context, *DeleteFileRequest) (*DeleteFileResponse, error)

func (UnimplementedClusterStorage2Server) DiskPartitionIsNTFS 

func (UnimplementedClusterStorage2Server) DiskPartitionIsNTFS(context.Context, *DiskPartitionIsNTFSRequest) (*DiskPartitionIsNTFSResponse, error)

func (UnimplementedClusterStorage2Server) GetArbSectors 

func (UnimplementedClusterStorage2Server) GetArbSectors(context.Context, *GetArbSectorsRequest) (*GetArbSectorsResponse, error)

func (UnimplementedClusterStorage2Server) GetDSMs 

func (UnimplementedClusterStorage2Server) GetDSMs(context.Context, *GetDSMsRequest) (*GetDSMsResponse, error)

func (UnimplementedClusterStorage2Server) GetFSName 

func (UnimplementedClusterStorage2Server) GetFSName(context.Context, *GetFSNameRequest) (*GetFSNameResponse, error)

func (UnimplementedClusterStorage2Server) GetProperties 

func (UnimplementedClusterStorage2Server) GetProperties(context.Context, *GetPropertiesRequest) (*GetPropertiesResponse, error)

func (UnimplementedClusterStorage2Server) GetUniqueIDs 

func (UnimplementedClusterStorage2Server) GetUniqueIDs(context.Context, *GetUniqueIDsRequest) (*GetUniqueIDsResponse, error)

func (UnimplementedClusterStorage2Server) IsOnline 

func (UnimplementedClusterStorage2Server) IsOnline(context.Context, *IsOnlineRequest) (*IsOnlineResponse, error)

func (UnimplementedClusterStorage2Server) IsPRPresent 

func (UnimplementedClusterStorage2Server) IsPRPresent(context.Context, *IsPRPresentRequest) (*IsPRPresentResponse, error)

func (UnimplementedClusterStorage2Server) IsReadable 

func (UnimplementedClusterStorage2Server) IsReadable(context.Context, *IsReadableRequest) (*IsReadableResponse, error)

func (UnimplementedClusterStorage2Server) Offline 

func (UnimplementedClusterStorage2Server) Offline(context.Context, *OfflineRequest) (*OfflineResponse, error)

func (UnimplementedClusterStorage2Server) Online 

func (UnimplementedClusterStorage2Server) Online(context.Context, *OnlineRequest) (*OnlineResponse, error)

func (UnimplementedClusterStorage2Server) PRArbitrate 

func (UnimplementedClusterStorage2Server) PRArbitrate(context.Context, *PRArbitrateRequest) (*PRArbitrateResponse, error)

func (UnimplementedClusterStorage2Server) PRClear 

func (UnimplementedClusterStorage2Server) PRClear(context.Context, *PRClearRequest) (*PRClearResponse, error)

func (UnimplementedClusterStorage2Server) PRPreempt 

func (UnimplementedClusterStorage2Server) PRPreempt(context.Context, *PRPreemptRequest) (*PRPreemptResponse, error)

func (UnimplementedClusterStorage2Server) PRRegister 

func (UnimplementedClusterStorage2Server) PRRegister(context.Context, *PRRegisterRequest) (*PRRegisterResponse, error)

func (UnimplementedClusterStorage2Server) PRRelease 

func (UnimplementedClusterStorage2Server) PRRelease(context.Context, *PRReleaseRequest) (*PRReleaseResponse, error)

func (UnimplementedClusterStorage2Server) PRReserve 

func (UnimplementedClusterStorage2Server) PRReserve(context.Context, *PRReserveRequest) (*PRReserveResponse, error)

func (UnimplementedClusterStorage2Server) PRUnregister 

func (UnimplementedClusterStorage2Server) PRUnregister(context.Context, *PRUnregisterRequest) (*PRUnregisterResponse, error)

func (UnimplementedClusterStorage2Server) PrepareNode 

func (UnimplementedClusterStorage2Server) PrepareNode(context.Context, *PrepareNodeRequest) (*PrepareNodeResponse, error)

func (UnimplementedClusterStorage2Server) PrepareNodePhase2 

func (UnimplementedClusterStorage2Server) PrepareNodePhase2(context.Context, *PrepareNodePhase2Request) (*PrepareNodePhase2Response, error)

func (UnimplementedClusterStorage2Server) RawRead 

func (UnimplementedClusterStorage2Server) RawRead(context.Context, *RawReadRequest) (*RawReadResponse, error)

func (UnimplementedClusterStorage2Server) RawWrite 

func (UnimplementedClusterStorage2Server) RawWrite(context.Context, *RawWriteRequest) (*RawWriteResponse, error)

func (UnimplementedClusterStorage2Server) SetOnline 

func (UnimplementedClusterStorage2Server) SetOnline(context.Context, *SetOnlineRequest) (*SetOnlineResponse, error)

func (UnimplementedClusterStorage2Server) StopDefense 

func (UnimplementedClusterStorage2Server) StopDefense(context.Context, *StopDefenseRequest) (*StopDefenseResponse, error)

func (UnimplementedClusterStorage2Server) VerifyFileData 

func (UnimplementedClusterStorage2Server) VerifyFileData(context.Context, *VerifyFileDataRequest) (*VerifyFileDataResponse, error)

func (UnimplementedClusterStorage2Server) VerifyUnique 

func (UnimplementedClusterStorage2Server) VerifyUnique(context.Context, *VerifyUniqueRequest) (*VerifyUniqueResponse, error)

func (UnimplementedClusterStorage2Server) WriteFileData 

func (UnimplementedClusterStorage2Server) WriteFileData(context.Context, *WriteFileDataRequest) (*WriteFileDataResponse, error)

type VerifyFileDataRequest 

type VerifyFileDataRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId:  The identifier of the ClusPrepDisk representing the disk that holds the
	// file to verify.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// ulPartition: The partition number of the partition associated with the volume on
	// the disk that holds the file to verify from.
	Partition uint32 `idl:"name:ulPartition" json:"partition"`
	// FileName:  The path and name of the file to verify from.
	FileName string `idl:"name:FileName;string" json:"file_name"`
	// cbDataIn:  The size, in bytes, of the buffer DataIn.
	DataInLength uint32 `idl:"name:cbDataIn" json:"data_in_length"`
	// DataIn:  The data to verify against the file.
	DataIn []byte `idl:"name:DataIn;size_is:(cbDataIn)" json:"data_in"`
}

VerifyFileDataRequest structure represents the CprepDiskVerifyFileData operation request

func (*VerifyFileDataRequest) MarshalNDR 

func (o *VerifyFileDataRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*VerifyFileDataRequest) UnmarshalNDR 

func (o *VerifyFileDataRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type VerifyFileDataResponse 

type VerifyFileDataResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskVerifyFileData return value.
	Return int32 `idl:"name:Return" json:"return"`
}

VerifyFileDataResponse structure represents the CprepDiskVerifyFileData operation response

func (*VerifyFileDataResponse) MarshalNDR 

func (o *VerifyFileDataResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*VerifyFileDataResponse) UnmarshalNDR 

func (o *VerifyFileDataResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type VerifyUniqueRequest 

type VerifyUniqueRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
}

VerifyUniqueRequest structure represents the CprepDiskVerifyUnique operation request

func (*VerifyUniqueRequest) MarshalNDR 

func (o *VerifyUniqueRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*VerifyUniqueRequest) UnmarshalNDR 

func (o *VerifyUniqueRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type VerifyUniqueResponse 

type VerifyUniqueResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskVerifyUnique return value.
	Return int32 `idl:"name:Return" json:"return"`
}

VerifyUniqueResponse structure represents the CprepDiskVerifyUnique operation response

func (*VerifyUniqueResponse) MarshalNDR 

func (o *VerifyUniqueResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*VerifyUniqueResponse) UnmarshalNDR 

func (o *VerifyUniqueResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type WriteFileDataRequest 

type WriteFileDataRequest struct {
	// This: ORPCTHIS structure that is used to send ORPC extension data to the server.
	This *dcom.ORPCThis `idl:"name:This" json:"this"`
	// DiskId: The identifier of the ClusPrepDisk representing the disk that holds the file
	// to write to.
	DiskID *csvp.ClusterDiskID `idl:"name:DiskId" json:"disk_id"`
	// ulPartition: The partition number of the partition associated with the volume on
	// the disk that holds the file to write to.
	Partition uint32 `idl:"name:ulPartition" json:"partition"`
	// FileName: The path and name of the file to write to.
	FileName string `idl:"name:FileName;string" json:"file_name"`
	// cbDataIn: The size, in bytes, of the buffer DataIn.
	DataInLength uint32 `idl:"name:cbDataIn" json:"data_in_length"`
	// DataIn: The data to write to the file.
	DataIn []byte `idl:"name:DataIn;size_is:(cbDataIn)" json:"data_in"`
}

WriteFileDataRequest structure represents the CprepDiskWriteFileData operation request

func (*WriteFileDataRequest) MarshalNDR 

func (o *WriteFileDataRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*WriteFileDataRequest) UnmarshalNDR 

func (o *WriteFileDataRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type WriteFileDataResponse 

type WriteFileDataResponse struct {
	// That: ORPCTHAT structure that is used to return ORPC extension data to the client.
	That *dcom.ORPCThat `idl:"name:That" json:"that"`
	// Return: The CprepDiskWriteFileData return value.
	Return int32 `idl:"name:Return" json:"return"`
}

WriteFileDataResponse structure represents the CprepDiskWriteFileData operation response

func (*WriteFileDataResponse) MarshalNDR 

func (o *WriteFileDataResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*WriteFileDataResponse) UnmarshalNDR 

func (o *WriteFileDataResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.