/* parser auto-generated by pidl */

#include "includes.h"
#include "bin/default/librpc/gen_ndr/ndr_fsrvp.h"

#include "librpc/gen_ndr/ndr_misc.h"
static enum ndr_err_code ndr_push_fssagent_share_mapping_1(struct ndr_push *ndr, int ndr_flags, const struct fssagent_share_mapping_1 *r)
{
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_push_align(ndr, 5));
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ShadowCopySetId));
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ShadowCopyId));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->ShareNameUNC));
		NDR_CHECK(ndr_push_unique_ptr(ndr, r->ShadowCopyShareName));
		NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->tstamp));
		NDR_CHECK(ndr_push_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->ShareNameUNC) {
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ShareNameUNC, CH_UTF16)));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ShareNameUNC, CH_UTF16)));
			NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ShareNameUNC, ndr_charset_length(r->ShareNameUNC, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		}
		if (r->ShadowCopyShareName) {
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ShadowCopyShareName, CH_UTF16)));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ShadowCopyShareName, CH_UTF16)));
			NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ShadowCopyShareName, ndr_charset_length(r->ShadowCopyShareName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fssagent_share_mapping_1(struct ndr_pull *ndr, int ndr_flags, struct fssagent_share_mapping_1 *r)
{
	uint32_t _ptr_ShareNameUNC;
	uint32_t size_ShareNameUNC_1 = 0;
	uint32_t length_ShareNameUNC_1 = 0;
	TALLOC_CTX *_mem_save_ShareNameUNC_0 = NULL;
	uint32_t _ptr_ShadowCopyShareName;
	uint32_t size_ShadowCopyShareName_1 = 0;
	uint32_t length_ShadowCopyShareName_1 = 0;
	TALLOC_CTX *_mem_save_ShadowCopyShareName_0 = NULL;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 5));
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ShadowCopySetId));
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ShadowCopyId));
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ShareNameUNC));
		if (_ptr_ShareNameUNC) {
			NDR_PULL_ALLOC(ndr, r->ShareNameUNC);
		} else {
			r->ShareNameUNC = NULL;
		}
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ShadowCopyShareName));
		if (_ptr_ShadowCopyShareName) {
			NDR_PULL_ALLOC(ndr, r->ShadowCopyShareName);
		} else {
			r->ShadowCopyShareName = NULL;
		}
		NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->tstamp));
		NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (r->ShareNameUNC) {
			_mem_save_ShareNameUNC_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->ShareNameUNC, 0);
			NDR_CHECK(ndr_pull_array_size(ndr, &r->ShareNameUNC));
			NDR_CHECK(ndr_pull_array_length(ndr, &r->ShareNameUNC));
			size_ShareNameUNC_1 = ndr_get_array_size(ndr, &r->ShareNameUNC);
			length_ShareNameUNC_1 = ndr_get_array_length(ndr, &r->ShareNameUNC);
			if (length_ShareNameUNC_1 > size_ShareNameUNC_1) {
				return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShareNameUNC_1, length_ShareNameUNC_1);
			}
			NDR_CHECK(ndr_check_string_terminator(ndr, length_ShareNameUNC_1, sizeof(uint16_t)));
			NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ShareNameUNC, length_ShareNameUNC_1, sizeof(uint16_t), CH_UTF16));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ShareNameUNC_0, 0);
		}
		if (r->ShadowCopyShareName) {
			_mem_save_ShadowCopyShareName_0 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, r->ShadowCopyShareName, 0);
			NDR_CHECK(ndr_pull_array_size(ndr, &r->ShadowCopyShareName));
			NDR_CHECK(ndr_pull_array_length(ndr, &r->ShadowCopyShareName));
			size_ShadowCopyShareName_1 = ndr_get_array_size(ndr, &r->ShadowCopyShareName);
			length_ShadowCopyShareName_1 = ndr_get_array_length(ndr, &r->ShadowCopyShareName);
			if (length_ShadowCopyShareName_1 > size_ShadowCopyShareName_1) {
				return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShadowCopyShareName_1, length_ShadowCopyShareName_1);
			}
			NDR_CHECK(ndr_check_string_terminator(ndr, length_ShadowCopyShareName_1, sizeof(uint16_t)));
			NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ShadowCopyShareName, length_ShadowCopyShareName_1, sizeof(uint16_t), CH_UTF16));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ShadowCopyShareName_0, 0);
		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fssagent_share_mapping_1(struct ndr_print *ndr, const char *name, const struct fssagent_share_mapping_1 *r)
{
	ndr_print_struct(ndr, name, "fssagent_share_mapping_1");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	ndr_print_GUID(ndr, "ShadowCopySetId", &r->ShadowCopySetId);
	ndr_print_GUID(ndr, "ShadowCopyId", &r->ShadowCopyId);
	ndr_print_ptr(ndr, "ShareNameUNC", r->ShareNameUNC);
	ndr->depth++;
	if (r->ShareNameUNC) {
		ndr_print_string(ndr, "ShareNameUNC", r->ShareNameUNC);
	}
	ndr->depth--;
	ndr_print_ptr(ndr, "ShadowCopyShareName", r->ShadowCopyShareName);
	ndr->depth++;
	if (r->ShadowCopyShareName) {
		ndr_print_string(ndr, "ShadowCopyShareName", r->ShadowCopyShareName);
	}
	ndr->depth--;
	ndr_print_NTTIME(ndr, "tstamp", r->tstamp);
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fssagent_share_mapping(struct ndr_push *ndr, int ndr_flags, const union fssagent_share_mapping *r)
{
	uint32_t level;
	NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		/* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
		NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
		NDR_CHECK(ndr_push_union_align(ndr, 5));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
		NDR_CHECK(ndr_push_union_align(ndr, 5));
		switch (level) {
			case 1: {
				NDR_CHECK(ndr_push_unique_ptr(ndr, r->ShareMapping1));
			break; }

			default: {
			break; }

		}
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (!(ndr_flags & NDR_SCALARS)) {
			/* We didn't get it above, and the token is not needed after this. */
			NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
		}
		switch (level) {
			case 1:
				if (r->ShareMapping1) {
					NDR_CHECK(ndr_push_fssagent_share_mapping_1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ShareMapping1));
				}
			break;

			default:
			break;

		}
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fssagent_share_mapping(struct ndr_pull *ndr, int ndr_flags, union fssagent_share_mapping *r)
{
	uint32_t level;
	uint32_t _level;
	TALLOC_CTX *_mem_save_ShareMapping1_0 = NULL;
	uint32_t _ptr_ShareMapping1;
	NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
	if (ndr_flags & NDR_SCALARS) {
		/* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
		NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
		NDR_CHECK(ndr_pull_union_align(ndr, 5));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
		if (_level != level) {
			return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
		}
		NDR_CHECK(ndr_pull_union_align(ndr, 5));
		switch (level) {
			case 1: {
				NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ShareMapping1));
				if (_ptr_ShareMapping1) {
					NDR_PULL_ALLOC(ndr, r->ShareMapping1);
				} else {
					r->ShareMapping1 = NULL;
				}
			break; }

			default: {
			break; }

		}
	}
	if (ndr_flags & NDR_BUFFERS) {
		if (!(ndr_flags & NDR_SCALARS)) {
			/* We didn't get it above, and the token is not needed after this. */
			NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
		}
		switch (level) {
			case 1:
				if (r->ShareMapping1) {
					_mem_save_ShareMapping1_0 = NDR_PULL_GET_MEM_CTX(ndr);
					NDR_PULL_SET_MEM_CTX(ndr, r->ShareMapping1, 0);
					NDR_CHECK(ndr_pull_fssagent_share_mapping_1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ShareMapping1));
					NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ShareMapping1_0, 0);
				}
			break;

			default:
			break;

		}
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fssagent_share_mapping(struct ndr_print *ndr, const char *name, const union fssagent_share_mapping *r)
{
	uint32_t level;
	level = ndr_print_steal_switch_value(ndr, r);
	ndr_print_union(ndr, name, level, "fssagent_share_mapping");
	switch (level) {
		case 1:
			ndr_print_ptr(ndr, "ShareMapping1", r->ShareMapping1);
			ndr->depth++;
			if (r->ShareMapping1) {
				ndr_print_fssagent_share_mapping_1(ndr, "ShareMapping1", r->ShareMapping1);
			}
			ndr->depth--;
		break;

		default:
		break;

	}
}

static enum ndr_err_code ndr_push_fss_GetSupportedVersion(struct ndr_push *ndr, int flags, const struct fss_GetSupportedVersion *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
	}
	if (flags & NDR_OUT) {
		if (r->out.MinVersion == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		if (r->out.MaxVersion == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.MinVersion));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.MaxVersion));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_GetSupportedVersion(struct ndr_pull *ndr, int flags, struct fss_GetSupportedVersion *r)
{
	TALLOC_CTX *_mem_save_MinVersion_0 = NULL;
	TALLOC_CTX *_mem_save_MaxVersion_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_PULL_ALLOC(ndr, r->out.MinVersion);
		NDR_ZERO_STRUCTP(r->out.MinVersion);
		NDR_PULL_ALLOC(ndr, r->out.MaxVersion);
		NDR_ZERO_STRUCTP(r->out.MaxVersion);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.MinVersion);
		}
		_mem_save_MinVersion_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.MinVersion, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.MinVersion));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MinVersion_0, LIBNDR_FLAG_REF_ALLOC);
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.MaxVersion);
		}
		_mem_save_MaxVersion_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.MaxVersion, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.MaxVersion));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MaxVersion_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_GetSupportedVersion(struct ndr_print *ndr, const char *name, int flags, const struct fss_GetSupportedVersion *r)
{
	ndr_print_struct(ndr, name, "fss_GetSupportedVersion");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_GetSupportedVersion");
		ndr->depth++;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_GetSupportedVersion");
		ndr->depth++;
		ndr_print_ptr(ndr, "MinVersion", r->out.MinVersion);
		ndr->depth++;
		ndr_print_uint32(ndr, "MinVersion", *r->out.MinVersion);
		ndr->depth--;
		ndr_print_ptr(ndr, "MaxVersion", r->out.MaxVersion);
		ndr->depth++;
		ndr_print_uint32(ndr, "MaxVersion", *r->out.MaxVersion);
		ndr->depth--;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_SetContext(struct ndr_push *ndr, int flags, const struct fss_SetContext *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Context));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_SetContext(struct ndr_pull *ndr, int flags, struct fss_SetContext *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Context));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_SetContext(struct ndr_print *ndr, const char *name, int flags, const struct fss_SetContext *r)
{
	ndr_print_struct(ndr, name, "fss_SetContext");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_SetContext");
		ndr->depth++;
		ndr_print_uint32(ndr, "Context", r->in.Context);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_SetContext");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_StartShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_StartShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ClientShadowCopySetId));
	}
	if (flags & NDR_OUT) {
		if (r->out.pShadowCopySetId == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->out.pShadowCopySetId));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_StartShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_StartShadowCopySet *r)
{
	TALLOC_CTX *_mem_save_pShadowCopySetId_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ClientShadowCopySetId));
		NDR_PULL_ALLOC(ndr, r->out.pShadowCopySetId);
		NDR_ZERO_STRUCTP(r->out.pShadowCopySetId);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.pShadowCopySetId);
		}
		_mem_save_pShadowCopySetId_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.pShadowCopySetId, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->out.pShadowCopySetId));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pShadowCopySetId_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_StartShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_StartShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_StartShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_StartShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ClientShadowCopySetId", &r->in.ClientShadowCopySetId);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_StartShadowCopySet");
		ndr->depth++;
		ndr_print_ptr(ndr, "pShadowCopySetId", r->out.pShadowCopySetId);
		ndr->depth++;
		ndr_print_GUID(ndr, "pShadowCopySetId", r->out.pShadowCopySetId);
		ndr->depth--;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_AddToShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_AddToShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.ShareName == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ClientShadowCopyId));
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ShareName, ndr_charset_length(r->in.ShareName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		if (r->out.pShadowCopyId == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->out.pShadowCopyId));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_AddToShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_AddToShadowCopySet *r)
{
	uint32_t size_ShareName_1 = 0;
	uint32_t length_ShareName_1 = 0;
	TALLOC_CTX *_mem_save_pShadowCopyId_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ClientShadowCopyId));
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ShareName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ShareName));
		size_ShareName_1 = ndr_get_array_size(ndr, &r->in.ShareName);
		length_ShareName_1 = ndr_get_array_length(ndr, &r->in.ShareName);
		if (length_ShareName_1 > size_ShareName_1) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShareName_1, length_ShareName_1);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_ShareName_1, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ShareName, length_ShareName_1, sizeof(uint16_t), CH_UTF16));
		NDR_PULL_ALLOC(ndr, r->out.pShadowCopyId);
		NDR_ZERO_STRUCTP(r->out.pShadowCopyId);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.pShadowCopyId);
		}
		_mem_save_pShadowCopyId_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.pShadowCopyId, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->out.pShadowCopyId));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pShadowCopyId_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_AddToShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_AddToShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_AddToShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_AddToShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ClientShadowCopyId", &r->in.ClientShadowCopyId);
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr_print_ptr(ndr, "ShareName", r->in.ShareName);
		ndr->depth++;
		ndr_print_string(ndr, "ShareName", r->in.ShareName);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_AddToShadowCopySet");
		ndr->depth++;
		ndr_print_ptr(ndr, "pShadowCopyId", r->out.pShadowCopyId);
		ndr->depth++;
		ndr_print_GUID(ndr, "pShadowCopyId", r->out.pShadowCopyId);
		ndr->depth--;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_CommitShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_CommitShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.TimeOutInMilliseconds));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_CommitShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_CommitShadowCopySet *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.TimeOutInMilliseconds));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_CommitShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_CommitShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_CommitShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_CommitShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr_print_uint32(ndr, "TimeOutInMilliseconds", r->in.TimeOutInMilliseconds);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_CommitShadowCopySet");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_ExposeShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_ExposeShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.TimeOutInMilliseconds));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_ExposeShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_ExposeShadowCopySet *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.TimeOutInMilliseconds));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_ExposeShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_ExposeShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_ExposeShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_ExposeShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr_print_uint32(ndr, "TimeOutInMilliseconds", r->in.TimeOutInMilliseconds);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_ExposeShadowCopySet");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_RecoveryCompleteShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_RecoveryCompleteShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_RecoveryCompleteShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_RecoveryCompleteShadowCopySet *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_RecoveryCompleteShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_RecoveryCompleteShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_RecoveryCompleteShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_RecoveryCompleteShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_RecoveryCompleteShadowCopySet");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_AbortShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_AbortShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_AbortShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_AbortShadowCopySet *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_AbortShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_AbortShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_AbortShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_AbortShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_AbortShadowCopySet");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_IsPathSupported(struct ndr_push *ndr, int flags, const struct fss_IsPathSupported *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.ShareName == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ShareName, ndr_charset_length(r->in.ShareName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		if (r->out.SupportedByThisProvider == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		if (r->out.OwnerMachineName == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.SupportedByThisProvider));
		NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.OwnerMachineName));
		if (*r->out.OwnerMachineName) {
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.OwnerMachineName, CH_UTF16)));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
			NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.OwnerMachineName, CH_UTF16)));
			NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.OwnerMachineName, ndr_charset_length(*r->out.OwnerMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		}
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_IsPathSupported(struct ndr_pull *ndr, int flags, struct fss_IsPathSupported *r)
{
	uint32_t size_ShareName_1 = 0;
	uint32_t length_ShareName_1 = 0;
	uint32_t _ptr_OwnerMachineName;
	uint32_t size_OwnerMachineName_2 = 0;
	uint32_t length_OwnerMachineName_2 = 0;
	TALLOC_CTX *_mem_save_SupportedByThisProvider_0 = NULL;
	TALLOC_CTX *_mem_save_OwnerMachineName_0 = NULL;
	TALLOC_CTX *_mem_save_OwnerMachineName_1 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ShareName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ShareName));
		size_ShareName_1 = ndr_get_array_size(ndr, &r->in.ShareName);
		length_ShareName_1 = ndr_get_array_length(ndr, &r->in.ShareName);
		if (length_ShareName_1 > size_ShareName_1) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShareName_1, length_ShareName_1);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_ShareName_1, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ShareName, length_ShareName_1, sizeof(uint16_t), CH_UTF16));
		NDR_PULL_ALLOC(ndr, r->out.SupportedByThisProvider);
		NDR_ZERO_STRUCTP(r->out.SupportedByThisProvider);
		NDR_PULL_ALLOC(ndr, r->out.OwnerMachineName);
		NDR_ZERO_STRUCTP(r->out.OwnerMachineName);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.SupportedByThisProvider);
		}
		_mem_save_SupportedByThisProvider_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.SupportedByThisProvider, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.SupportedByThisProvider));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_SupportedByThisProvider_0, LIBNDR_FLAG_REF_ALLOC);
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.OwnerMachineName);
		}
		_mem_save_OwnerMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.OwnerMachineName, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_OwnerMachineName));
		if (_ptr_OwnerMachineName) {
			NDR_PULL_ALLOC(ndr, *r->out.OwnerMachineName);
		} else {
			*r->out.OwnerMachineName = NULL;
		}
		if (*r->out.OwnerMachineName) {
			_mem_save_OwnerMachineName_1 = NDR_PULL_GET_MEM_CTX(ndr);
			NDR_PULL_SET_MEM_CTX(ndr, *r->out.OwnerMachineName, 0);
			NDR_CHECK(ndr_pull_array_size(ndr, r->out.OwnerMachineName));
			NDR_CHECK(ndr_pull_array_length(ndr, r->out.OwnerMachineName));
			size_OwnerMachineName_2 = ndr_get_array_size(ndr, r->out.OwnerMachineName);
			length_OwnerMachineName_2 = ndr_get_array_length(ndr, r->out.OwnerMachineName);
			if (length_OwnerMachineName_2 > size_OwnerMachineName_2) {
				return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_OwnerMachineName_2, length_OwnerMachineName_2);
			}
			NDR_CHECK(ndr_check_string_terminator(ndr, length_OwnerMachineName_2, sizeof(uint16_t)));
			NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.OwnerMachineName, length_OwnerMachineName_2, sizeof(uint16_t), CH_UTF16));
			NDR_PULL_SET_MEM_CTX(ndr, _mem_save_OwnerMachineName_1, 0);
		}
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_OwnerMachineName_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_IsPathSupported(struct ndr_print *ndr, const char *name, int flags, const struct fss_IsPathSupported *r)
{
	ndr_print_struct(ndr, name, "fss_IsPathSupported");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_IsPathSupported");
		ndr->depth++;
		ndr_print_ptr(ndr, "ShareName", r->in.ShareName);
		ndr->depth++;
		ndr_print_string(ndr, "ShareName", r->in.ShareName);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_IsPathSupported");
		ndr->depth++;
		ndr_print_ptr(ndr, "SupportedByThisProvider", r->out.SupportedByThisProvider);
		ndr->depth++;
		ndr_print_uint32(ndr, "SupportedByThisProvider", *r->out.SupportedByThisProvider);
		ndr->depth--;
		ndr_print_ptr(ndr, "OwnerMachineName", r->out.OwnerMachineName);
		ndr->depth++;
		ndr_print_ptr(ndr, "OwnerMachineName", *r->out.OwnerMachineName);
		ndr->depth++;
		if (*r->out.OwnerMachineName) {
			ndr_print_string(ndr, "OwnerMachineName", *r->out.OwnerMachineName);
		}
		ndr->depth--;
		ndr->depth--;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_IsPathShadowCopied(struct ndr_push *ndr, int flags, const struct fss_IsPathShadowCopied *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.ShareName == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ShareName, ndr_charset_length(r->in.ShareName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		if (r->out.ShadowCopyPresent == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		if (r->out.ShadowCopyCompatibility == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.ShadowCopyPresent));
		NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.ShadowCopyCompatibility));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_IsPathShadowCopied(struct ndr_pull *ndr, int flags, struct fss_IsPathShadowCopied *r)
{
	uint32_t size_ShareName_1 = 0;
	uint32_t length_ShareName_1 = 0;
	TALLOC_CTX *_mem_save_ShadowCopyPresent_0 = NULL;
	TALLOC_CTX *_mem_save_ShadowCopyCompatibility_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ShareName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ShareName));
		size_ShareName_1 = ndr_get_array_size(ndr, &r->in.ShareName);
		length_ShareName_1 = ndr_get_array_length(ndr, &r->in.ShareName);
		if (length_ShareName_1 > size_ShareName_1) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShareName_1, length_ShareName_1);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_ShareName_1, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ShareName, length_ShareName_1, sizeof(uint16_t), CH_UTF16));
		NDR_PULL_ALLOC(ndr, r->out.ShadowCopyPresent);
		NDR_ZERO_STRUCTP(r->out.ShadowCopyPresent);
		NDR_PULL_ALLOC(ndr, r->out.ShadowCopyCompatibility);
		NDR_ZERO_STRUCTP(r->out.ShadowCopyCompatibility);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.ShadowCopyPresent);
		}
		_mem_save_ShadowCopyPresent_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.ShadowCopyPresent, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.ShadowCopyPresent));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ShadowCopyPresent_0, LIBNDR_FLAG_REF_ALLOC);
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.ShadowCopyCompatibility);
		}
		_mem_save_ShadowCopyCompatibility_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.ShadowCopyCompatibility, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.ShadowCopyCompatibility));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ShadowCopyCompatibility_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_IsPathShadowCopied(struct ndr_print *ndr, const char *name, int flags, const struct fss_IsPathShadowCopied *r)
{
	ndr_print_struct(ndr, name, "fss_IsPathShadowCopied");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_IsPathShadowCopied");
		ndr->depth++;
		ndr_print_ptr(ndr, "ShareName", r->in.ShareName);
		ndr->depth++;
		ndr_print_string(ndr, "ShareName", r->in.ShareName);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_IsPathShadowCopied");
		ndr->depth++;
		ndr_print_ptr(ndr, "ShadowCopyPresent", r->out.ShadowCopyPresent);
		ndr->depth++;
		ndr_print_uint32(ndr, "ShadowCopyPresent", *r->out.ShadowCopyPresent);
		ndr->depth--;
		ndr_print_ptr(ndr, "ShadowCopyCompatibility", r->out.ShadowCopyCompatibility);
		ndr->depth++;
		ndr_print_int32(ndr, "ShadowCopyCompatibility", *r->out.ShadowCopyCompatibility);
		ndr->depth--;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_GetShareMapping(struct ndr_push *ndr, int flags, const struct fss_GetShareMapping *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.ShareName == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopyId));
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ShareName, ndr_charset_length(r->in.ShareName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Level));
	}
	if (flags & NDR_OUT) {
		if (r->out.ShareMapping == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ShareMapping, r->in.Level));
		NDR_CHECK(ndr_push_fssagent_share_mapping(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ShareMapping));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_GetShareMapping(struct ndr_pull *ndr, int flags, struct fss_GetShareMapping *r)
{
	uint32_t size_ShareName_1 = 0;
	uint32_t length_ShareName_1 = 0;
	TALLOC_CTX *_mem_save_ShareMapping_0 = NULL;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_ZERO_STRUCT(r->out);

		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopyId));
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ShareName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ShareName));
		size_ShareName_1 = ndr_get_array_size(ndr, &r->in.ShareName);
		length_ShareName_1 = ndr_get_array_length(ndr, &r->in.ShareName);
		if (length_ShareName_1 > size_ShareName_1) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShareName_1, length_ShareName_1);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_ShareName_1, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ShareName, length_ShareName_1, sizeof(uint16_t), CH_UTF16));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Level));
		NDR_PULL_ALLOC(ndr, r->out.ShareMapping);
		NDR_ZERO_STRUCTP(r->out.ShareMapping);
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
			NDR_PULL_ALLOC(ndr, r->out.ShareMapping);
		}
		_mem_save_ShareMapping_0 = NDR_PULL_GET_MEM_CTX(ndr);
		NDR_PULL_SET_MEM_CTX(ndr, r->out.ShareMapping, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ShareMapping, r->in.Level));
		NDR_CHECK(ndr_pull_fssagent_share_mapping(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ShareMapping));
		NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ShareMapping_0, LIBNDR_FLAG_REF_ALLOC);
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_GetShareMapping(struct ndr_print *ndr, const char *name, int flags, const struct fss_GetShareMapping *r)
{
	ndr_print_struct(ndr, name, "fss_GetShareMapping");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_GetShareMapping");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopyId", &r->in.ShadowCopyId);
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr_print_ptr(ndr, "ShareName", r->in.ShareName);
		ndr->depth++;
		ndr_print_string(ndr, "ShareName", r->in.ShareName);
		ndr->depth--;
		ndr_print_uint32(ndr, "Level", r->in.Level);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_GetShareMapping");
		ndr->depth++;
		ndr_print_ptr(ndr, "ShareMapping", r->out.ShareMapping);
		ndr->depth++;
		ndr_print_set_switch_value(ndr, r->out.ShareMapping, r->in.Level);
		ndr_print_fssagent_share_mapping(ndr, "ShareMapping", r->out.ShareMapping);
		ndr->depth--;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_DeleteShareMapping(struct ndr_push *ndr, int flags, const struct fss_DeleteShareMapping *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		if (r->in.ShareName == NULL) {
			return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
		}
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopyId));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
		NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ShareName, CH_UTF16)));
		NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ShareName, ndr_charset_length(r->in.ShareName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_DeleteShareMapping(struct ndr_pull *ndr, int flags, struct fss_DeleteShareMapping *r)
{
	uint32_t size_ShareName_1 = 0;
	uint32_t length_ShareName_1 = 0;
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopyId));
		NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ShareName));
		NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ShareName));
		size_ShareName_1 = ndr_get_array_size(ndr, &r->in.ShareName);
		length_ShareName_1 = ndr_get_array_length(ndr, &r->in.ShareName);
		if (length_ShareName_1 > size_ShareName_1) {
			return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ShareName_1, length_ShareName_1);
		}
		NDR_CHECK(ndr_check_string_terminator(ndr, length_ShareName_1, sizeof(uint16_t)));
		NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ShareName, length_ShareName_1, sizeof(uint16_t), CH_UTF16));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_DeleteShareMapping(struct ndr_print *ndr, const char *name, int flags, const struct fss_DeleteShareMapping *r)
{
	ndr_print_struct(ndr, name, "fss_DeleteShareMapping");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_DeleteShareMapping");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr_print_GUID(ndr, "ShadowCopyId", &r->in.ShadowCopyId);
		ndr_print_ptr(ndr, "ShareName", r->in.ShareName);
		ndr->depth++;
		ndr_print_string(ndr, "ShareName", r->in.ShareName);
		ndr->depth--;
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_DeleteShareMapping");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

static enum ndr_err_code ndr_push_fss_PrepareShadowCopySet(struct ndr_push *ndr, int flags, const struct fss_PrepareShadowCopySet *r)
{
	NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.TimeOutInMilliseconds));
	}
	if (flags & NDR_OUT) {
		NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

static enum ndr_err_code ndr_pull_fss_PrepareShadowCopySet(struct ndr_pull *ndr, int flags, struct fss_PrepareShadowCopySet *r)
{
	NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
	if (flags & NDR_IN) {
		NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.ShadowCopySetId));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.TimeOutInMilliseconds));
	}
	if (flags & NDR_OUT) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
	}
	return NDR_ERR_SUCCESS;
}

_PUBLIC_ void ndr_print_fss_PrepareShadowCopySet(struct ndr_print *ndr, const char *name, int flags, const struct fss_PrepareShadowCopySet *r)
{
	ndr_print_struct(ndr, name, "fss_PrepareShadowCopySet");
	if (r == NULL) { ndr_print_null(ndr); return; }
	ndr->depth++;
	if (flags & NDR_SET_VALUES) {
		ndr->flags |= LIBNDR_PRINT_SET_VALUES;
	}
	if (flags & NDR_IN) {
		ndr_print_struct(ndr, "in", "fss_PrepareShadowCopySet");
		ndr->depth++;
		ndr_print_GUID(ndr, "ShadowCopySetId", &r->in.ShadowCopySetId);
		ndr_print_uint32(ndr, "TimeOutInMilliseconds", r->in.TimeOutInMilliseconds);
		ndr->depth--;
	}
	if (flags & NDR_OUT) {
		ndr_print_struct(ndr, "out", "fss_PrepareShadowCopySet");
		ndr->depth++;
		ndr_print_uint32(ndr, "result", r->out.result);
		ndr->depth--;
	}
	ndr->depth--;
}

#ifndef SKIP_NDR_TABLE_FileServerVssAgent
static const struct ndr_interface_public_struct FileServerVssAgent_public_structs[] = {
	{ .name = NULL }
};

static const struct ndr_interface_call FileServerVssAgent_calls[] = {
	{
		"fss_GetSupportedVersion",
		sizeof(struct fss_GetSupportedVersion),
		(ndr_push_flags_fn_t) ndr_push_fss_GetSupportedVersion,
		(ndr_pull_flags_fn_t) ndr_pull_fss_GetSupportedVersion,
		(ndr_print_function_t) ndr_print_fss_GetSupportedVersion,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_SetContext",
		sizeof(struct fss_SetContext),
		(ndr_push_flags_fn_t) ndr_push_fss_SetContext,
		(ndr_pull_flags_fn_t) ndr_pull_fss_SetContext,
		(ndr_print_function_t) ndr_print_fss_SetContext,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_StartShadowCopySet",
		sizeof(struct fss_StartShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_StartShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_StartShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_StartShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_AddToShadowCopySet",
		sizeof(struct fss_AddToShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_AddToShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_AddToShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_AddToShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_CommitShadowCopySet",
		sizeof(struct fss_CommitShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_CommitShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_CommitShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_CommitShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_ExposeShadowCopySet",
		sizeof(struct fss_ExposeShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_ExposeShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_ExposeShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_ExposeShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_RecoveryCompleteShadowCopySet",
		sizeof(struct fss_RecoveryCompleteShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_RecoveryCompleteShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_RecoveryCompleteShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_RecoveryCompleteShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_AbortShadowCopySet",
		sizeof(struct fss_AbortShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_AbortShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_AbortShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_AbortShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_IsPathSupported",
		sizeof(struct fss_IsPathSupported),
		(ndr_push_flags_fn_t) ndr_push_fss_IsPathSupported,
		(ndr_pull_flags_fn_t) ndr_pull_fss_IsPathSupported,
		(ndr_print_function_t) ndr_print_fss_IsPathSupported,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_IsPathShadowCopied",
		sizeof(struct fss_IsPathShadowCopied),
		(ndr_push_flags_fn_t) ndr_push_fss_IsPathShadowCopied,
		(ndr_pull_flags_fn_t) ndr_pull_fss_IsPathShadowCopied,
		(ndr_print_function_t) ndr_print_fss_IsPathShadowCopied,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_GetShareMapping",
		sizeof(struct fss_GetShareMapping),
		(ndr_push_flags_fn_t) ndr_push_fss_GetShareMapping,
		(ndr_pull_flags_fn_t) ndr_pull_fss_GetShareMapping,
		(ndr_print_function_t) ndr_print_fss_GetShareMapping,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_DeleteShareMapping",
		sizeof(struct fss_DeleteShareMapping),
		(ndr_push_flags_fn_t) ndr_push_fss_DeleteShareMapping,
		(ndr_pull_flags_fn_t) ndr_pull_fss_DeleteShareMapping,
		(ndr_print_function_t) ndr_print_fss_DeleteShareMapping,
		{ 0, NULL },
		{ 0, NULL },
	},
	{
		"fss_PrepareShadowCopySet",
		sizeof(struct fss_PrepareShadowCopySet),
		(ndr_push_flags_fn_t) ndr_push_fss_PrepareShadowCopySet,
		(ndr_pull_flags_fn_t) ndr_pull_fss_PrepareShadowCopySet,
		(ndr_print_function_t) ndr_print_fss_PrepareShadowCopySet,
		{ 0, NULL },
		{ 0, NULL },
	},
	{ .name = NULL }
};

static const char * const FileServerVssAgent_endpoint_strings[] = {
	"ncacn_np:[\\pipe\\FssagentRpc]", 
};

static const struct ndr_interface_string_array FileServerVssAgent_endpoints = {
	.count	= 1,
	.names	= FileServerVssAgent_endpoint_strings
};

static const char * const FileServerVssAgent_authservice_strings[] = {
	"host", 
};

static const struct ndr_interface_string_array FileServerVssAgent_authservices = {
	.count	= 1,
	.names	= FileServerVssAgent_authservice_strings
};


const struct ndr_interface_table ndr_table_FileServerVssAgent = {
	.name		= "FileServerVssAgent",
	.syntax_id	= {
		{0xa8e0653c,0x2744,0x4389,{0xa6,0x1d},{0x73,0x73,0xdf,0x8b,0x22,0x92}},
		NDR_FILESERVERVSSAGENT_VERSION
	},
	.helpstring	= NDR_FILESERVERVSSAGENT_HELPSTRING,
	.num_calls	= 13,
	.calls		= FileServerVssAgent_calls,
	.num_public_structs	= 0,
	.public_structs		= FileServerVssAgent_public_structs,
	.endpoints	= &FileServerVssAgent_endpoints,
	.authservices	= &FileServerVssAgent_authservices
};

#endif /* SKIP_NDR_TABLE_FileServerVssAgent */