// Code generated by updateApiRouting.go - DO NOT EDIT.
package api

import (
	"fmt"
	"net/http"
)

// Do not modify: This is an automatically generated file created by updateApiRouting.go
// It contains the code that is used to parse the headers submitted in an API request

// ParseRequest parses the header file. As paramFilesListSingle has no fields with the
// tag header, this method does nothing, except calling ProcessParameter()
func (p *paramFilesListSingle) ParseRequest(r *http.Request) error {
	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesListSingle struct
func (p *paramFilesListSingle) New() requestParser {
	return &paramFilesListSingle{}
}

// ParseRequest parses the header file. As paramFilesAdd has no fields with the
// tag header, this method does nothing, except calling ProcessParameter()
func (p *paramFilesAdd) ParseRequest(r *http.Request) error {
	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesAdd struct
func (p *paramFilesAdd) New() requestParser {
	return &paramFilesAdd{}
}

// ParseRequest reads r and saves the passed header values in the paramFilesChangeOwner struct
// In the end, ProcessParameter() is called
func (p *paramFilesChangeOwner) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "id", required: true
	exists, err = checkHeaderExists(r, "id", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["id"] = exists
	if exists {
		p.Id = r.Header.Get("id")
	}

	// RequestParser header value "newOwner", required: true
	exists, err = checkHeaderExists(r, "newOwner", true, false)
	if err != nil {
		return err
	}
	p.foundHeaders["newOwner"] = exists
	if exists {
		p.NewOwner, err = parseHeaderInt(r, "newOwner")
		if err != nil {
			return fmt.Errorf("invalid value in header newOwner supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesChangeOwner struct
func (p *paramFilesChangeOwner) New() requestParser {
	return &paramFilesChangeOwner{}
}

// ParseRequest reads r and saves the passed header values in the paramFilesDuplicate struct
// In the end, ProcessParameter() is called
func (p *paramFilesDuplicate) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "id", required: true
	exists, err = checkHeaderExists(r, "id", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["id"] = exists
	if exists {
		p.Id = r.Header.Get("id")
	}

	// RequestParser header value "allowedDownloads", required: false
	exists, err = checkHeaderExists(r, "allowedDownloads", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["allowedDownloads"] = exists
	if exists {
		p.AllowedDownloads, err = parseHeaderInt(r, "allowedDownloads")
		if err != nil {
			return fmt.Errorf("invalid value in header allowedDownloads supplied")
		}
	}

	// RequestParser header value "expiryDays", required: false
	exists, err = checkHeaderExists(r, "expiryDays", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["expiryDays"] = exists
	if exists {
		p.ExpiryDays, err = parseHeaderInt(r, "expiryDays")
		if err != nil {
			return fmt.Errorf("invalid value in header expiryDays supplied")
		}
	}

	// RequestParser header value "password", required: false
	exists, err = checkHeaderExists(r, "password", false, true)
	if err != nil {
		return err
	}
	p.foundHeaders["password"] = exists
	if exists {
		p.Password = r.Header.Get("password")
	}

	// RequestParser header value "originalPassword", required: false
	exists, err = checkHeaderExists(r, "originalPassword", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["originalPassword"] = exists
	if exists {
		p.KeepPassword, err = parseHeaderBool(r, "originalPassword")
		if err != nil {
			return fmt.Errorf("invalid value in header originalPassword supplied")
		}
	}

	// RequestParser header value "filename", required: false
	exists, err = checkHeaderExists(r, "filename", false, true)
	if err != nil {
		return err
	}
	p.foundHeaders["filename"] = exists
	if exists {
		p.FileName = r.Header.Get("filename")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesDuplicate struct
func (p *paramFilesDuplicate) New() requestParser {
	return &paramFilesDuplicate{}
}

// ParseRequest reads r and saves the passed header values in the paramFilesModify struct
// In the end, ProcessParameter() is called
func (p *paramFilesModify) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "id", required: true
	exists, err = checkHeaderExists(r, "id", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["id"] = exists
	if exists {
		p.Id = r.Header.Get("id")
	}

	// RequestParser header value "allowedDownloads", required: false
	exists, err = checkHeaderExists(r, "allowedDownloads", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["allowedDownloads"] = exists
	if exists {
		p.AllowedDownloads, err = parseHeaderInt(r, "allowedDownloads")
		if err != nil {
			return fmt.Errorf("invalid value in header allowedDownloads supplied")
		}
	}

	// RequestParser header value "expiryTimestamp", required: false
	exists, err = checkHeaderExists(r, "expiryTimestamp", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["expiryTimestamp"] = exists
	if exists {
		p.ExpiryTimestamp, err = parseHeaderInt64(r, "expiryTimestamp")
		if err != nil {
			return fmt.Errorf("invalid value in header expiryTimestamp supplied")
		}
	}

	// RequestParser header value "password", required: false
	exists, err = checkHeaderExists(r, "password", false, true)
	if err != nil {
		return err
	}
	p.foundHeaders["password"] = exists
	if exists {
		p.Password = r.Header.Get("password")
	}

	// RequestParser header value "originalPassword", required: false
	exists, err = checkHeaderExists(r, "originalPassword", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["originalPassword"] = exists
	if exists {
		p.KeepPassword, err = parseHeaderBool(r, "originalPassword")
		if err != nil {
			return fmt.Errorf("invalid value in header originalPassword supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesModify struct
func (p *paramFilesModify) New() requestParser {
	return &paramFilesModify{}
}

// ParseRequest reads r and saves the passed header values in the paramFilesReplace struct
// In the end, ProcessParameter() is called
func (p *paramFilesReplace) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "id", required: true
	exists, err = checkHeaderExists(r, "id", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["id"] = exists
	if exists {
		p.Id = r.Header.Get("id")
	}

	// RequestParser header value "idNewContent", required: true
	exists, err = checkHeaderExists(r, "idNewContent", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["idNewContent"] = exists
	if exists {
		p.IdNewContent = r.Header.Get("idNewContent")
	}

	// RequestParser header value "deleteNewFile", required: false
	exists, err = checkHeaderExists(r, "deleteNewFile", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["deleteNewFile"] = exists
	if exists {
		p.Delete, err = parseHeaderBool(r, "deleteNewFile")
		if err != nil {
			return fmt.Errorf("invalid value in header deleteNewFile supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesReplace struct
func (p *paramFilesReplace) New() requestParser {
	return &paramFilesReplace{}
}

// ParseRequest reads r and saves the passed header values in the paramFilesDelete struct
// In the end, ProcessParameter() is called
func (p *paramFilesDelete) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "id", required: true
	exists, err = checkHeaderExists(r, "id", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["id"] = exists
	if exists {
		p.Id = r.Header.Get("id")
	}

	// RequestParser header value "delay", required: false
	exists, err = checkHeaderExists(r, "delay", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["delay"] = exists
	if exists {
		p.DelaySeconds, err = parseHeaderInt(r, "delay")
		if err != nil {
			return fmt.Errorf("invalid value in header delay supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesDelete struct
func (p *paramFilesDelete) New() requestParser {
	return &paramFilesDelete{}
}

// ParseRequest reads r and saves the passed header values in the paramFilesRestore struct
// In the end, ProcessParameter() is called
func (p *paramFilesRestore) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "id", required: true
	exists, err = checkHeaderExists(r, "id", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["id"] = exists
	if exists {
		p.Id = r.Header.Get("id")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramFilesRestore struct
func (p *paramFilesRestore) New() requestParser {
	return &paramFilesRestore{}
}

// ParseRequest reads r and saves the passed header values in the paramAuthCreate struct
// In the end, ProcessParameter() is called
func (p *paramAuthCreate) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "friendlyName", required: false
	exists, err = checkHeaderExists(r, "friendlyName", false, true)
	if err != nil {
		return err
	}
	p.foundHeaders["friendlyName"] = exists
	if exists {
		p.FriendlyName = r.Header.Get("friendlyName")
	}

	// RequestParser header value "basicPermissions", required: false
	exists, err = checkHeaderExists(r, "basicPermissions", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["basicPermissions"] = exists
	if exists {
		p.BasicPermissions, err = parseHeaderBool(r, "basicPermissions")
		if err != nil {
			return fmt.Errorf("invalid value in header basicPermissions supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramAuthCreate struct
func (p *paramAuthCreate) New() requestParser {
	return &paramAuthCreate{}
}

// ParseRequest reads r and saves the passed header values in the paramAuthFriendlyName struct
// In the end, ProcessParameter() is called
func (p *paramAuthFriendlyName) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "targetKey", required: true
	exists, err = checkHeaderExists(r, "targetKey", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["targetKey"] = exists
	if exists {
		p.KeyId = r.Header.Get("targetKey")
	}

	// RequestParser header value "friendlyName", required: true
	exists, err = checkHeaderExists(r, "friendlyName", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["friendlyName"] = exists
	if exists {
		p.FriendlyName = r.Header.Get("friendlyName")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramAuthFriendlyName struct
func (p *paramAuthFriendlyName) New() requestParser {
	return &paramAuthFriendlyName{}
}

// ParseRequest reads r and saves the passed header values in the paramAuthModify struct
// In the end, ProcessParameter() is called
func (p *paramAuthModify) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "targetKey", required: true
	exists, err = checkHeaderExists(r, "targetKey", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["targetKey"] = exists
	if exists {
		p.KeyId = r.Header.Get("targetKey")
	}

	// RequestParser header value "permission", required: true
	exists, err = checkHeaderExists(r, "permission", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["permission"] = exists
	if exists {
		p.permissionRaw = r.Header.Get("permission")
	}

	// RequestParser header value "permissionModifier", required: true
	exists, err = checkHeaderExists(r, "permissionModifier", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["permissionModifier"] = exists
	if exists {
		p.permissionModifier = r.Header.Get("permissionModifier")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramAuthModify struct
func (p *paramAuthModify) New() requestParser {
	return &paramAuthModify{}
}

// ParseRequest reads r and saves the passed header values in the paramAuthDelete struct
// In the end, ProcessParameter() is called
func (p *paramAuthDelete) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "targetKey", required: true
	exists, err = checkHeaderExists(r, "targetKey", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["targetKey"] = exists
	if exists {
		p.KeyId = r.Header.Get("targetKey")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramAuthDelete struct
func (p *paramAuthDelete) New() requestParser {
	return &paramAuthDelete{}
}

// ParseRequest reads r and saves the passed header values in the paramUserCreate struct
// In the end, ProcessParameter() is called
func (p *paramUserCreate) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "username", required: true
	exists, err = checkHeaderExists(r, "username", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["username"] = exists
	if exists {
		p.Username = r.Header.Get("username")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramUserCreate struct
func (p *paramUserCreate) New() requestParser {
	return &paramUserCreate{}
}

// ParseRequest reads r and saves the passed header values in the paramUserChangeRank struct
// In the end, ProcessParameter() is called
func (p *paramUserChangeRank) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "userid", required: true
	exists, err = checkHeaderExists(r, "userid", true, false)
	if err != nil {
		return err
	}
	p.foundHeaders["userid"] = exists
	if exists {
		p.Id, err = parseHeaderInt(r, "userid")
		if err != nil {
			return fmt.Errorf("invalid value in header userid supplied")
		}
	}

	// RequestParser header value "newRank", required: true
	exists, err = checkHeaderExists(r, "newRank", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["newRank"] = exists
	if exists {
		p.newRankRaw = r.Header.Get("newRank")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramUserChangeRank struct
func (p *paramUserChangeRank) New() requestParser {
	return &paramUserChangeRank{}
}

// ParseRequest reads r and saves the passed header values in the paramUserDelete struct
// In the end, ProcessParameter() is called
func (p *paramUserDelete) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "userid", required: true
	exists, err = checkHeaderExists(r, "userid", true, false)
	if err != nil {
		return err
	}
	p.foundHeaders["userid"] = exists
	if exists {
		p.Id, err = parseHeaderInt(r, "userid")
		if err != nil {
			return fmt.Errorf("invalid value in header userid supplied")
		}
	}

	// RequestParser header value "deleteFiles", required: false
	exists, err = checkHeaderExists(r, "deleteFiles", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["deleteFiles"] = exists
	if exists {
		p.DeleteFiles, err = parseHeaderBool(r, "deleteFiles")
		if err != nil {
			return fmt.Errorf("invalid value in header deleteFiles supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramUserDelete struct
func (p *paramUserDelete) New() requestParser {
	return &paramUserDelete{}
}

// ParseRequest reads r and saves the passed header values in the paramUserModify struct
// In the end, ProcessParameter() is called
func (p *paramUserModify) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "userid", required: true
	exists, err = checkHeaderExists(r, "userid", true, false)
	if err != nil {
		return err
	}
	p.foundHeaders["userid"] = exists
	if exists {
		p.Id, err = parseHeaderInt(r, "userid")
		if err != nil {
			return fmt.Errorf("invalid value in header userid supplied")
		}
	}

	// RequestParser header value "userpermission", required: true
	exists, err = checkHeaderExists(r, "userpermission", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["userpermission"] = exists
	if exists {
		p.permissionRaw = r.Header.Get("userpermission")
	}

	// RequestParser header value "permissionModifier", required: true
	exists, err = checkHeaderExists(r, "permissionModifier", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["permissionModifier"] = exists
	if exists {
		p.permissionModifier = r.Header.Get("permissionModifier")
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramUserModify struct
func (p *paramUserModify) New() requestParser {
	return &paramUserModify{}
}

// ParseRequest reads r and saves the passed header values in the paramUserResetPw struct
// In the end, ProcessParameter() is called
func (p *paramUserResetPw) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "userid", required: true
	exists, err = checkHeaderExists(r, "userid", true, false)
	if err != nil {
		return err
	}
	p.foundHeaders["userid"] = exists
	if exists {
		p.Id, err = parseHeaderInt(r, "userid")
		if err != nil {
			return fmt.Errorf("invalid value in header userid supplied")
		}
	}

	// RequestParser header value "generateNewPassword", required: false
	exists, err = checkHeaderExists(r, "generateNewPassword", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["generateNewPassword"] = exists
	if exists {
		p.NewPassword, err = parseHeaderBool(r, "generateNewPassword")
		if err != nil {
			return fmt.Errorf("invalid value in header generateNewPassword supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramUserResetPw struct
func (p *paramUserResetPw) New() requestParser {
	return &paramUserResetPw{}
}

// ParseRequest parses the header file. As paramE2eStore has no fields with the
// tag header, this method does nothing, except calling ProcessParameter()
func (p *paramE2eStore) ParseRequest(r *http.Request) error {
	return p.ProcessParameter(r)
}

// New returns a new instance of paramE2eStore struct
func (p *paramE2eStore) New() requestParser {
	return &paramE2eStore{}
}

// ParseRequest reads r and saves the passed header values in the paramLogsDelete struct
// In the end, ProcessParameter() is called
func (p *paramLogsDelete) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "timestamp", required: false
	exists, err = checkHeaderExists(r, "timestamp", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["timestamp"] = exists
	if exists {
		p.Timestamp, err = parseHeaderInt64(r, "timestamp")
		if err != nil {
			return fmt.Errorf("invalid value in header timestamp supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramLogsDelete struct
func (p *paramLogsDelete) New() requestParser {
	return &paramLogsDelete{}
}

// ParseRequest parses the header file. As paramChunkAdd has no fields with the
// tag header, this method does nothing, except calling ProcessParameter()
func (p *paramChunkAdd) ParseRequest(r *http.Request) error {
	return p.ProcessParameter(r)
}

// New returns a new instance of paramChunkAdd struct
func (p *paramChunkAdd) New() requestParser {
	return &paramChunkAdd{}
}

// ParseRequest reads r and saves the passed header values in the paramChunkComplete struct
// In the end, ProcessParameter() is called
func (p *paramChunkComplete) ParseRequest(r *http.Request) error {
	var err error
	var exists bool
	p.foundHeaders = make(map[string]bool)

	// RequestParser header value "uuid", required: true
	exists, err = checkHeaderExists(r, "uuid", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["uuid"] = exists
	if exists {
		p.Uuid = r.Header.Get("uuid")
	}

	// RequestParser header value "filename", required: true
	exists, err = checkHeaderExists(r, "filename", true, true)
	if err != nil {
		return err
	}
	p.foundHeaders["filename"] = exists
	if exists {
		p.FileName = r.Header.Get("filename")
	}

	// RequestParser header value "filesize", required: true
	exists, err = checkHeaderExists(r, "filesize", true, false)
	if err != nil {
		return err
	}
	p.foundHeaders["filesize"] = exists
	if exists {
		p.FileSize, err = parseHeaderInt64(r, "filesize")
		if err != nil {
			return fmt.Errorf("invalid value in header filesize supplied")
		}
	}

	// RequestParser header value "realsize", required: false
	exists, err = checkHeaderExists(r, "realsize", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["realsize"] = exists
	if exists {
		p.RealSize, err = parseHeaderInt64(r, "realsize")
		if err != nil {
			return fmt.Errorf("invalid value in header realsize supplied")
		}
	}

	// RequestParser header value "contenttype", required: false
	exists, err = checkHeaderExists(r, "contenttype", false, true)
	if err != nil {
		return err
	}
	p.foundHeaders["contenttype"] = exists
	if exists {
		p.ContentType = r.Header.Get("contenttype")
	}

	// RequestParser header value "allowedDownloads", required: false
	exists, err = checkHeaderExists(r, "allowedDownloads", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["allowedDownloads"] = exists
	if exists {
		p.AllowedDownloads, err = parseHeaderInt(r, "allowedDownloads")
		if err != nil {
			return fmt.Errorf("invalid value in header allowedDownloads supplied")
		}
	}

	// RequestParser header value "expiryDays", required: false
	exists, err = checkHeaderExists(r, "expiryDays", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["expiryDays"] = exists
	if exists {
		p.ExpiryDays, err = parseHeaderInt(r, "expiryDays")
		if err != nil {
			return fmt.Errorf("invalid value in header expiryDays supplied")
		}
	}

	// RequestParser header value "password", required: false
	exists, err = checkHeaderExists(r, "password", false, true)
	if err != nil {
		return err
	}
	p.foundHeaders["password"] = exists
	if exists {
		p.Password = r.Header.Get("password")
	}

	// RequestParser header value "isE2E", required: false
	exists, err = checkHeaderExists(r, "isE2E", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["isE2E"] = exists
	if exists {
		p.IsE2E, err = parseHeaderBool(r, "isE2E")
		if err != nil {
			return fmt.Errorf("invalid value in header isE2E supplied")
		}
	}

	// RequestParser header value "nonblocking", required: false
	exists, err = checkHeaderExists(r, "nonblocking", false, false)
	if err != nil {
		return err
	}
	p.foundHeaders["nonblocking"] = exists
	if exists {
		p.IsNonBlocking, err = parseHeaderBool(r, "nonblocking")
		if err != nil {
			return fmt.Errorf("invalid value in header nonblocking supplied")
		}
	}

	return p.ProcessParameter(r)
}

// New returns a new instance of paramChunkComplete struct
func (p *paramChunkComplete) New() requestParser {
	return &paramChunkComplete{}
}
