/* Python wrapper functions auto-generated by pidl */
#include <Python.h>
#include "includes.h"
#include <pytalloc.h>
#include "librpc/rpc/pyrpc.h"
#include "librpc/rpc/pyrpc_util.h"
#include "librpc/gen_ndr/ndr_dfs.h"
#include "librpc/gen_ndr/ndr_dfs_c.h"

#include "librpc/gen_ndr/misc.h"
staticforward PyTypeObject dfs_Info0_Type;
staticforward PyTypeObject dfs_Info1_Type;
staticforward PyTypeObject dfs_Info2_Type;
staticforward PyTypeObject dfs_StorageInfo_Type;
staticforward PyTypeObject dfs_Info3_Type;
staticforward PyTypeObject dfs_Info4_Type;
staticforward PyTypeObject dfs_Info5_Type;
staticforward PyTypeObject dfs_Target_Priority_Type;
staticforward PyTypeObject dfs_StorageInfo2_Type;
staticforward PyTypeObject dfs_Info6_Type;
staticforward PyTypeObject dfs_Info7_Type;
staticforward PyTypeObject dfs_Info100_Type;
staticforward PyTypeObject dfs_Info101_Type;
staticforward PyTypeObject dfs_Info102_Type;
staticforward PyTypeObject dfs_Info103_Type;
staticforward PyTypeObject dfs_Info104_Type;
staticforward PyTypeObject dfs_Info105_Type;
staticforward PyTypeObject dfs_Info106_Type;
staticforward PyTypeObject dfs_Info200_Type;
staticforward PyTypeObject dfs_Info300_Type;
staticforward PyTypeObject dfs_EnumArray1_Type;
staticforward PyTypeObject dfs_EnumArray2_Type;
staticforward PyTypeObject dfs_EnumArray3_Type;
staticforward PyTypeObject dfs_EnumArray4_Type;
staticforward PyTypeObject dfs_EnumArray5_Type;
staticforward PyTypeObject dfs_EnumArray6_Type;
staticforward PyTypeObject dfs_EnumArray200_Type;
staticforward PyTypeObject dfs_EnumArray300_Type;
staticforward PyTypeObject dfs_EnumStruct_Type;
staticforward PyTypeObject dfs_UnknownStruct_Type;
staticforward PyTypeObject netdfs_InterfaceType;

void initdfs(void);static PyTypeObject *Object_Type;
static PyTypeObject *ClientConnection_Type;
static PyTypeObject *GUID_Type;

static PyObject *py_dfs_Info0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info0, type);
}


static PyTypeObject dfs_Info0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info0",
	.tp_getset = NULL,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info0_new,
};


static PyObject *py_dfs_Info1_get_path(PyObject *obj, void *closure)
{
	struct dfs_Info1 *object = (struct dfs_Info1 *)py_talloc_get_ptr(obj);
	PyObject *py_path;
	if (object->path == NULL) {
		py_path = Py_None;
		Py_INCREF(py_path);
	} else {
		if (object->path == NULL) {
			py_path = Py_None;
			Py_INCREF(py_path);
		} else {
			py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
		}
	}
	return py_path;
}

static int py_dfs_Info1_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info1 *object = (struct dfs_Info1 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->path = NULL;
	} else {
		object->path = NULL;
		if (PyUnicode_Check(value)) {
			object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->path = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info1_getsetters[] = {
	{ discard_const_p(char, "path"), py_dfs_Info1_get_path, py_dfs_Info1_set_path },
	{ NULL }
};

static PyObject *py_dfs_Info1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info1, type);
}


static PyTypeObject dfs_Info1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info1",
	.tp_getset = py_dfs_Info1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info1_new,
};


static PyObject *py_dfs_Info2_get_path(PyObject *obj, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(obj);
	PyObject *py_path;
	if (object->path == NULL) {
		py_path = Py_None;
		Py_INCREF(py_path);
	} else {
		if (object->path == NULL) {
			py_path = Py_None;
			Py_INCREF(py_path);
		} else {
			py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
		}
	}
	return py_path;
}

static int py_dfs_Info2_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->path = NULL;
	} else {
		object->path = NULL;
		if (PyUnicode_Check(value)) {
			object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->path = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info2_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info2_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info2_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info2_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info2_get_num_stores(PyObject *obj, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(obj);
	PyObject *py_num_stores;
	py_num_stores = PyInt_FromLong(object->num_stores);
	return py_num_stores;
}

static int py_dfs_Info2_set_num_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info2 *object = (struct dfs_Info2 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_stores = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_dfs_Info2_getsetters[] = {
	{ discard_const_p(char, "path"), py_dfs_Info2_get_path, py_dfs_Info2_set_path },
	{ discard_const_p(char, "comment"), py_dfs_Info2_get_comment, py_dfs_Info2_set_comment },
	{ discard_const_p(char, "state"), py_dfs_Info2_get_state, py_dfs_Info2_set_state },
	{ discard_const_p(char, "num_stores"), py_dfs_Info2_get_num_stores, py_dfs_Info2_set_num_stores },
	{ NULL }
};

static PyObject *py_dfs_Info2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info2, type);
}


static PyTypeObject dfs_Info2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info2",
	.tp_getset = py_dfs_Info2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info2_new,
};


static PyObject *py_dfs_StorageInfo_get_state(PyObject *obj, void *closure)
{
	struct dfs_StorageInfo *object = (struct dfs_StorageInfo *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_StorageInfo_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_StorageInfo *object = (struct dfs_StorageInfo *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_StorageInfo_get_server(PyObject *obj, void *closure)
{
	struct dfs_StorageInfo *object = (struct dfs_StorageInfo *)py_talloc_get_ptr(obj);
	PyObject *py_server;
	if (object->server == NULL) {
		py_server = Py_None;
		Py_INCREF(py_server);
	} else {
		if (object->server == NULL) {
			py_server = Py_None;
			Py_INCREF(py_server);
		} else {
			py_server = PyUnicode_Decode(object->server, strlen(object->server), "utf-8", "ignore");
		}
	}
	return py_server;
}

static int py_dfs_StorageInfo_set_server(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_StorageInfo *object = (struct dfs_StorageInfo *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->server = NULL;
	} else {
		object->server = NULL;
		if (PyUnicode_Check(value)) {
			object->server = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->server = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_StorageInfo_get_share(PyObject *obj, void *closure)
{
	struct dfs_StorageInfo *object = (struct dfs_StorageInfo *)py_talloc_get_ptr(obj);
	PyObject *py_share;
	if (object->share == NULL) {
		py_share = Py_None;
		Py_INCREF(py_share);
	} else {
		if (object->share == NULL) {
			py_share = Py_None;
			Py_INCREF(py_share);
		} else {
			py_share = PyUnicode_Decode(object->share, strlen(object->share), "utf-8", "ignore");
		}
	}
	return py_share;
}

static int py_dfs_StorageInfo_set_share(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_StorageInfo *object = (struct dfs_StorageInfo *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->share = NULL;
	} else {
		object->share = NULL;
		if (PyUnicode_Check(value)) {
			object->share = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->share = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_StorageInfo_getsetters[] = {
	{ discard_const_p(char, "state"), py_dfs_StorageInfo_get_state, py_dfs_StorageInfo_set_state },
	{ discard_const_p(char, "server"), py_dfs_StorageInfo_get_server, py_dfs_StorageInfo_set_server },
	{ discard_const_p(char, "share"), py_dfs_StorageInfo_get_share, py_dfs_StorageInfo_set_share },
	{ NULL }
};

static PyObject *py_dfs_StorageInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_StorageInfo, type);
}


static PyTypeObject dfs_StorageInfo_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.StorageInfo",
	.tp_getset = py_dfs_StorageInfo_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_StorageInfo_new,
};


static PyObject *py_dfs_Info3_get_path(PyObject *obj, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(obj);
	PyObject *py_path;
	if (object->path == NULL) {
		py_path = Py_None;
		Py_INCREF(py_path);
	} else {
		if (object->path == NULL) {
			py_path = Py_None;
			Py_INCREF(py_path);
		} else {
			py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
		}
	}
	return py_path;
}

static int py_dfs_Info3_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->path = NULL;
	} else {
		object->path = NULL;
		if (PyUnicode_Check(value)) {
			object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->path = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info3_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info3_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info3_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info3_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info3_get_num_stores(PyObject *obj, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(obj);
	PyObject *py_num_stores;
	py_num_stores = PyInt_FromLong(object->num_stores);
	return py_num_stores;
}

static int py_dfs_Info3_set_num_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_stores = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info3_get_stores(PyObject *obj, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(obj);
	PyObject *py_stores;
	if (object->stores == NULL) {
		py_stores = Py_None;
		Py_INCREF(py_stores);
	} else {
		py_stores = PyList_New(object->num_stores);
		if (py_stores == NULL) {
			return NULL;
		}
		{
			int stores_cntr_1;
			for (stores_cntr_1 = 0; stores_cntr_1 < object->num_stores; stores_cntr_1++) {
				PyObject *py_stores_1;
				py_stores_1 = py_talloc_reference_ex(&dfs_StorageInfo_Type, object->stores, &object->stores[stores_cntr_1]);
				PyList_SetItem(py_stores, stores_cntr_1, py_stores_1);
			}
		}
	}
	return py_stores;
}

static int py_dfs_Info3_set_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info3 *object = (struct dfs_Info3 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->stores);
	if (value == Py_None) {
		object->stores = NULL;
	} else {
		object->stores = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int stores_cntr_1;
			object->stores = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->stores, PyList_GET_SIZE(value));
			if (!object->stores) { return -1;; }
			talloc_set_name_const(object->stores, "ARRAY: object->stores");
			for (stores_cntr_1 = 0; stores_cntr_1 < PyList_GET_SIZE(value); stores_cntr_1++) {
				PY_CHECK_TYPE(&dfs_StorageInfo_Type, PyList_GET_ITEM(value, stores_cntr_1), return -1;);
				if (talloc_reference(object->stores, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, stores_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->stores[stores_cntr_1] = *(struct dfs_StorageInfo *)py_talloc_get_ptr(PyList_GET_ITEM(value, stores_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info3_getsetters[] = {
	{ discard_const_p(char, "path"), py_dfs_Info3_get_path, py_dfs_Info3_set_path },
	{ discard_const_p(char, "comment"), py_dfs_Info3_get_comment, py_dfs_Info3_set_comment },
	{ discard_const_p(char, "state"), py_dfs_Info3_get_state, py_dfs_Info3_set_state },
	{ discard_const_p(char, "num_stores"), py_dfs_Info3_get_num_stores, py_dfs_Info3_set_num_stores },
	{ discard_const_p(char, "stores"), py_dfs_Info3_get_stores, py_dfs_Info3_set_stores },
	{ NULL }
};

static PyObject *py_dfs_Info3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info3, type);
}


static PyTypeObject dfs_Info3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info3",
	.tp_getset = py_dfs_Info3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info3_new,
};


static PyObject *py_dfs_Info4_get_path(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_path;
	if (object->path == NULL) {
		py_path = Py_None;
		Py_INCREF(py_path);
	} else {
		if (object->path == NULL) {
			py_path = Py_None;
			Py_INCREF(py_path);
		} else {
			py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
		}
	}
	return py_path;
}

static int py_dfs_Info4_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->path = NULL;
	} else {
		object->path = NULL;
		if (PyUnicode_Check(value)) {
			object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->path = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info4_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info4_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info4_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info4_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info4_get_timeout(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_timeout;
	py_timeout = PyInt_FromLong(object->timeout);
	return py_timeout;
}

static int py_dfs_Info4_set_timeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timeout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info4_get_guid(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_guid;
	py_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->guid);
	return py_guid;
}

static int py_dfs_Info4_set_guid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->guid = *(struct GUID *)py_talloc_get_ptr(value);
	return 0;
}

static PyObject *py_dfs_Info4_get_num_stores(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_num_stores;
	py_num_stores = PyInt_FromLong(object->num_stores);
	return py_num_stores;
}

static int py_dfs_Info4_set_num_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_stores = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info4_get_stores(PyObject *obj, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(obj);
	PyObject *py_stores;
	if (object->stores == NULL) {
		py_stores = Py_None;
		Py_INCREF(py_stores);
	} else {
		py_stores = PyList_New(object->num_stores);
		if (py_stores == NULL) {
			return NULL;
		}
		{
			int stores_cntr_1;
			for (stores_cntr_1 = 0; stores_cntr_1 < object->num_stores; stores_cntr_1++) {
				PyObject *py_stores_1;
				py_stores_1 = py_talloc_reference_ex(&dfs_StorageInfo_Type, object->stores, &object->stores[stores_cntr_1]);
				PyList_SetItem(py_stores, stores_cntr_1, py_stores_1);
			}
		}
	}
	return py_stores;
}

static int py_dfs_Info4_set_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info4 *object = (struct dfs_Info4 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->stores);
	if (value == Py_None) {
		object->stores = NULL;
	} else {
		object->stores = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int stores_cntr_1;
			object->stores = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->stores, PyList_GET_SIZE(value));
			if (!object->stores) { return -1;; }
			talloc_set_name_const(object->stores, "ARRAY: object->stores");
			for (stores_cntr_1 = 0; stores_cntr_1 < PyList_GET_SIZE(value); stores_cntr_1++) {
				PY_CHECK_TYPE(&dfs_StorageInfo_Type, PyList_GET_ITEM(value, stores_cntr_1), return -1;);
				if (talloc_reference(object->stores, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, stores_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->stores[stores_cntr_1] = *(struct dfs_StorageInfo *)py_talloc_get_ptr(PyList_GET_ITEM(value, stores_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info4_getsetters[] = {
	{ discard_const_p(char, "path"), py_dfs_Info4_get_path, py_dfs_Info4_set_path },
	{ discard_const_p(char, "comment"), py_dfs_Info4_get_comment, py_dfs_Info4_set_comment },
	{ discard_const_p(char, "state"), py_dfs_Info4_get_state, py_dfs_Info4_set_state },
	{ discard_const_p(char, "timeout"), py_dfs_Info4_get_timeout, py_dfs_Info4_set_timeout },
	{ discard_const_p(char, "guid"), py_dfs_Info4_get_guid, py_dfs_Info4_set_guid },
	{ discard_const_p(char, "num_stores"), py_dfs_Info4_get_num_stores, py_dfs_Info4_set_num_stores },
	{ discard_const_p(char, "stores"), py_dfs_Info4_get_stores, py_dfs_Info4_set_stores },
	{ NULL }
};

static PyObject *py_dfs_Info4_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info4, type);
}


static PyTypeObject dfs_Info4_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info4",
	.tp_getset = py_dfs_Info4_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info4_new,
};


static PyObject *py_dfs_Info5_get_path(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_path;
	if (object->path == NULL) {
		py_path = Py_None;
		Py_INCREF(py_path);
	} else {
		if (object->path == NULL) {
			py_path = Py_None;
			Py_INCREF(py_path);
		} else {
			py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
		}
	}
	return py_path;
}

static int py_dfs_Info5_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->path = NULL;
	} else {
		object->path = NULL;
		if (PyUnicode_Check(value)) {
			object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->path = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info5_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info5_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info5_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info5_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info5_get_timeout(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_timeout;
	py_timeout = PyInt_FromLong(object->timeout);
	return py_timeout;
}

static int py_dfs_Info5_set_timeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timeout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info5_get_guid(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_guid;
	py_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->guid);
	return py_guid;
}

static int py_dfs_Info5_set_guid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->guid = *(struct GUID *)py_talloc_get_ptr(value);
	return 0;
}

static PyObject *py_dfs_Info5_get_flags(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyInt_FromLong(object->flags);
	return py_flags;
}

static int py_dfs_Info5_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->flags = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->flags = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info5_get_pktsize(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_pktsize;
	py_pktsize = PyInt_FromLong(object->pktsize);
	return py_pktsize;
}

static int py_dfs_Info5_set_pktsize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->pktsize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info5_get_num_stores(PyObject *obj, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(obj);
	PyObject *py_num_stores;
	py_num_stores = PyInt_FromLong(object->num_stores);
	return py_num_stores;
}

static int py_dfs_Info5_set_num_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info5 *object = (struct dfs_Info5 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_stores = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_dfs_Info5_getsetters[] = {
	{ discard_const_p(char, "path"), py_dfs_Info5_get_path, py_dfs_Info5_set_path },
	{ discard_const_p(char, "comment"), py_dfs_Info5_get_comment, py_dfs_Info5_set_comment },
	{ discard_const_p(char, "state"), py_dfs_Info5_get_state, py_dfs_Info5_set_state },
	{ discard_const_p(char, "timeout"), py_dfs_Info5_get_timeout, py_dfs_Info5_set_timeout },
	{ discard_const_p(char, "guid"), py_dfs_Info5_get_guid, py_dfs_Info5_set_guid },
	{ discard_const_p(char, "flags"), py_dfs_Info5_get_flags, py_dfs_Info5_set_flags },
	{ discard_const_p(char, "pktsize"), py_dfs_Info5_get_pktsize, py_dfs_Info5_set_pktsize },
	{ discard_const_p(char, "num_stores"), py_dfs_Info5_get_num_stores, py_dfs_Info5_set_num_stores },
	{ NULL }
};

static PyObject *py_dfs_Info5_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info5, type);
}


static PyTypeObject dfs_Info5_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info5",
	.tp_getset = py_dfs_Info5_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info5_new,
};


static PyObject *py_dfs_Target_Priority_get_target_priority_class(PyObject *obj, void *closure)
{
	struct dfs_Target_Priority *object = (struct dfs_Target_Priority *)py_talloc_get_ptr(obj);
	PyObject *py_target_priority_class;
	py_target_priority_class = PyInt_FromLong(object->target_priority_class);
	return py_target_priority_class;
}

static int py_dfs_Target_Priority_set_target_priority_class(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Target_Priority *object = (struct dfs_Target_Priority *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->target_priority_class = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->target_priority_class = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Target_Priority_get_target_priority_rank(PyObject *obj, void *closure)
{
	struct dfs_Target_Priority *object = (struct dfs_Target_Priority *)py_talloc_get_ptr(obj);
	PyObject *py_target_priority_rank;
	py_target_priority_rank = PyInt_FromLong(object->target_priority_rank);
	return py_target_priority_rank;
}

static int py_dfs_Target_Priority_set_target_priority_rank(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Target_Priority *object = (struct dfs_Target_Priority *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->target_priority_rank = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Target_Priority_get_reserved(PyObject *obj, void *closure)
{
	struct dfs_Target_Priority *object = (struct dfs_Target_Priority *)py_talloc_get_ptr(obj);
	PyObject *py_reserved;
	py_reserved = PyInt_FromLong(object->reserved);
	return py_reserved;
}

static int py_dfs_Target_Priority_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Target_Priority *object = (struct dfs_Target_Priority *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->reserved = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_dfs_Target_Priority_getsetters[] = {
	{ discard_const_p(char, "target_priority_class"), py_dfs_Target_Priority_get_target_priority_class, py_dfs_Target_Priority_set_target_priority_class },
	{ discard_const_p(char, "target_priority_rank"), py_dfs_Target_Priority_get_target_priority_rank, py_dfs_Target_Priority_set_target_priority_rank },
	{ discard_const_p(char, "reserved"), py_dfs_Target_Priority_get_reserved, py_dfs_Target_Priority_set_reserved },
	{ NULL }
};

static PyObject *py_dfs_Target_Priority_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Target_Priority, type);
}


static PyTypeObject dfs_Target_Priority_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Target_Priority",
	.tp_getset = py_dfs_Target_Priority_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Target_Priority_new,
};


static PyObject *py_dfs_StorageInfo2_get_info(PyObject *obj, void *closure)
{
	struct dfs_StorageInfo2 *object = (struct dfs_StorageInfo2 *)py_talloc_get_ptr(obj);
	PyObject *py_info;
	py_info = py_talloc_reference_ex(&dfs_StorageInfo_Type, py_talloc_get_mem_ctx(obj), &object->info);
	return py_info;
}

static int py_dfs_StorageInfo2_set_info(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_StorageInfo2 *object = (struct dfs_StorageInfo2 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&dfs_StorageInfo_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->info = *(struct dfs_StorageInfo *)py_talloc_get_ptr(value);
	return 0;
}

static PyObject *py_dfs_StorageInfo2_get_target_priority(PyObject *obj, void *closure)
{
	struct dfs_StorageInfo2 *object = (struct dfs_StorageInfo2 *)py_talloc_get_ptr(obj);
	PyObject *py_target_priority;
	py_target_priority = py_talloc_reference_ex(&dfs_Target_Priority_Type, py_talloc_get_mem_ctx(obj), &object->target_priority);
	return py_target_priority;
}

static int py_dfs_StorageInfo2_set_target_priority(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_StorageInfo2 *object = (struct dfs_StorageInfo2 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&dfs_Target_Priority_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->target_priority = *(struct dfs_Target_Priority *)py_talloc_get_ptr(value);
	return 0;
}

static PyGetSetDef py_dfs_StorageInfo2_getsetters[] = {
	{ discard_const_p(char, "info"), py_dfs_StorageInfo2_get_info, py_dfs_StorageInfo2_set_info },
	{ discard_const_p(char, "target_priority"), py_dfs_StorageInfo2_get_target_priority, py_dfs_StorageInfo2_set_target_priority },
	{ NULL }
};

static PyObject *py_dfs_StorageInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_StorageInfo2, type);
}


static PyTypeObject dfs_StorageInfo2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.StorageInfo2",
	.tp_getset = py_dfs_StorageInfo2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_StorageInfo2_new,
};


static PyObject *py_dfs_Info6_get_entry_path(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_entry_path;
	if (object->entry_path == NULL) {
		py_entry_path = Py_None;
		Py_INCREF(py_entry_path);
	} else {
		if (object->entry_path == NULL) {
			py_entry_path = Py_None;
			Py_INCREF(py_entry_path);
		} else {
			py_entry_path = PyUnicode_Decode(object->entry_path, strlen(object->entry_path), "utf-8", "ignore");
		}
	}
	return py_entry_path;
}

static int py_dfs_Info6_set_entry_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->entry_path = NULL;
	} else {
		object->entry_path = NULL;
		if (PyUnicode_Check(value)) {
			object->entry_path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->entry_path = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info6_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info6_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info6_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info6_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info6_get_timeout(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_timeout;
	py_timeout = PyInt_FromLong(object->timeout);
	return py_timeout;
}

static int py_dfs_Info6_set_timeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timeout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info6_get_guid(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_guid;
	py_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->guid);
	return py_guid;
}

static int py_dfs_Info6_set_guid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->guid = *(struct GUID *)py_talloc_get_ptr(value);
	return 0;
}

static PyObject *py_dfs_Info6_get_flags(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyInt_FromLong(object->flags);
	return py_flags;
}

static int py_dfs_Info6_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->flags = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->flags = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info6_get_pktsize(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_pktsize;
	py_pktsize = PyInt_FromLong(object->pktsize);
	return py_pktsize;
}

static int py_dfs_Info6_set_pktsize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->pktsize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info6_get_num_stores(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_num_stores;
	py_num_stores = PyInt_FromLong(object->num_stores);
	return py_num_stores;
}

static int py_dfs_Info6_set_num_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_stores = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info6_get_stores(PyObject *obj, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(obj);
	PyObject *py_stores;
	if (object->stores == NULL) {
		py_stores = Py_None;
		Py_INCREF(py_stores);
	} else {
		py_stores = PyList_New(object->num_stores);
		if (py_stores == NULL) {
			return NULL;
		}
		{
			int stores_cntr_1;
			for (stores_cntr_1 = 0; stores_cntr_1 < object->num_stores; stores_cntr_1++) {
				PyObject *py_stores_1;
				py_stores_1 = py_talloc_reference_ex(&dfs_StorageInfo2_Type, object->stores, &object->stores[stores_cntr_1]);
				PyList_SetItem(py_stores, stores_cntr_1, py_stores_1);
			}
		}
	}
	return py_stores;
}

static int py_dfs_Info6_set_stores(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info6 *object = (struct dfs_Info6 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->stores);
	if (value == Py_None) {
		object->stores = NULL;
	} else {
		object->stores = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int stores_cntr_1;
			object->stores = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->stores, PyList_GET_SIZE(value));
			if (!object->stores) { return -1;; }
			talloc_set_name_const(object->stores, "ARRAY: object->stores");
			for (stores_cntr_1 = 0; stores_cntr_1 < PyList_GET_SIZE(value); stores_cntr_1++) {
				PY_CHECK_TYPE(&dfs_StorageInfo2_Type, PyList_GET_ITEM(value, stores_cntr_1), return -1;);
				if (talloc_reference(object->stores, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, stores_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->stores[stores_cntr_1] = *(struct dfs_StorageInfo2 *)py_talloc_get_ptr(PyList_GET_ITEM(value, stores_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info6_getsetters[] = {
	{ discard_const_p(char, "entry_path"), py_dfs_Info6_get_entry_path, py_dfs_Info6_set_entry_path },
	{ discard_const_p(char, "comment"), py_dfs_Info6_get_comment, py_dfs_Info6_set_comment },
	{ discard_const_p(char, "state"), py_dfs_Info6_get_state, py_dfs_Info6_set_state },
	{ discard_const_p(char, "timeout"), py_dfs_Info6_get_timeout, py_dfs_Info6_set_timeout },
	{ discard_const_p(char, "guid"), py_dfs_Info6_get_guid, py_dfs_Info6_set_guid },
	{ discard_const_p(char, "flags"), py_dfs_Info6_get_flags, py_dfs_Info6_set_flags },
	{ discard_const_p(char, "pktsize"), py_dfs_Info6_get_pktsize, py_dfs_Info6_set_pktsize },
	{ discard_const_p(char, "num_stores"), py_dfs_Info6_get_num_stores, py_dfs_Info6_set_num_stores },
	{ discard_const_p(char, "stores"), py_dfs_Info6_get_stores, py_dfs_Info6_set_stores },
	{ NULL }
};

static PyObject *py_dfs_Info6_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info6, type);
}


static PyTypeObject dfs_Info6_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info6",
	.tp_getset = py_dfs_Info6_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info6_new,
};


static PyObject *py_dfs_Info7_get_generation_guid(PyObject *obj, void *closure)
{
	struct dfs_Info7 *object = (struct dfs_Info7 *)py_talloc_get_ptr(obj);
	PyObject *py_generation_guid;
	py_generation_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->generation_guid);
	return py_generation_guid;
}

static int py_dfs_Info7_set_generation_guid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info7 *object = (struct dfs_Info7 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->generation_guid = *(struct GUID *)py_talloc_get_ptr(value);
	return 0;
}

static PyGetSetDef py_dfs_Info7_getsetters[] = {
	{ discard_const_p(char, "generation_guid"), py_dfs_Info7_get_generation_guid, py_dfs_Info7_set_generation_guid },
	{ NULL }
};

static PyObject *py_dfs_Info7_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info7, type);
}


static PyTypeObject dfs_Info7_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info7",
	.tp_getset = py_dfs_Info7_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info7_new,
};


static PyObject *py_dfs_Info100_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info100 *object = (struct dfs_Info100 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info100_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info100 *object = (struct dfs_Info100 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info100_getsetters[] = {
	{ discard_const_p(char, "comment"), py_dfs_Info100_get_comment, py_dfs_Info100_set_comment },
	{ NULL }
};

static PyObject *py_dfs_Info100_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info100, type);
}


static PyTypeObject dfs_Info100_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info100",
	.tp_getset = py_dfs_Info100_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info100_new,
};


static PyObject *py_dfs_Info101_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info101 *object = (struct dfs_Info101 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info101_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info101 *object = (struct dfs_Info101 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyGetSetDef py_dfs_Info101_getsetters[] = {
	{ discard_const_p(char, "state"), py_dfs_Info101_get_state, py_dfs_Info101_set_state },
	{ NULL }
};

static PyObject *py_dfs_Info101_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info101, type);
}


static PyTypeObject dfs_Info101_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info101",
	.tp_getset = py_dfs_Info101_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info101_new,
};


static PyObject *py_dfs_Info102_get_timeout(PyObject *obj, void *closure)
{
	struct dfs_Info102 *object = (struct dfs_Info102 *)py_talloc_get_ptr(obj);
	PyObject *py_timeout;
	py_timeout = PyInt_FromLong(object->timeout);
	return py_timeout;
}

static int py_dfs_Info102_set_timeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info102 *object = (struct dfs_Info102 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timeout = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_dfs_Info102_getsetters[] = {
	{ discard_const_p(char, "timeout"), py_dfs_Info102_get_timeout, py_dfs_Info102_set_timeout },
	{ NULL }
};

static PyObject *py_dfs_Info102_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info102, type);
}


static PyTypeObject dfs_Info102_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info102",
	.tp_getset = py_dfs_Info102_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info102_new,
};


static PyObject *py_dfs_Info103_get_flags(PyObject *obj, void *closure)
{
	struct dfs_Info103 *object = (struct dfs_Info103 *)py_talloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyInt_FromLong(object->flags);
	return py_flags;
}

static int py_dfs_Info103_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info103 *object = (struct dfs_Info103 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->flags = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->flags = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyGetSetDef py_dfs_Info103_getsetters[] = {
	{ discard_const_p(char, "flags"), py_dfs_Info103_get_flags, py_dfs_Info103_set_flags },
	{ NULL }
};

static PyObject *py_dfs_Info103_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info103, type);
}


static PyTypeObject dfs_Info103_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info103",
	.tp_getset = py_dfs_Info103_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info103_new,
};


static PyObject *py_dfs_Info104_get_priority(PyObject *obj, void *closure)
{
	struct dfs_Info104 *object = (struct dfs_Info104 *)py_talloc_get_ptr(obj);
	PyObject *py_priority;
	py_priority = py_talloc_reference_ex(&dfs_Target_Priority_Type, py_talloc_get_mem_ctx(obj), &object->priority);
	return py_priority;
}

static int py_dfs_Info104_set_priority(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info104 *object = (struct dfs_Info104 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&dfs_Target_Priority_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->priority = *(struct dfs_Target_Priority *)py_talloc_get_ptr(value);
	return 0;
}

static PyGetSetDef py_dfs_Info104_getsetters[] = {
	{ discard_const_p(char, "priority"), py_dfs_Info104_get_priority, py_dfs_Info104_set_priority },
	{ NULL }
};

static PyObject *py_dfs_Info104_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info104, type);
}


static PyTypeObject dfs_Info104_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info104",
	.tp_getset = py_dfs_Info104_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info104_new,
};


static PyObject *py_dfs_Info105_get_comment(PyObject *obj, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(obj);
	PyObject *py_comment;
	if (object->comment == NULL) {
		py_comment = Py_None;
		Py_INCREF(py_comment);
	} else {
		if (object->comment == NULL) {
			py_comment = Py_None;
			Py_INCREF(py_comment);
		} else {
			py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
		}
	}
	return py_comment;
}

static int py_dfs_Info105_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->comment = NULL;
	} else {
		object->comment = NULL;
		if (PyUnicode_Check(value)) {
			object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->comment = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_dfs_Info105_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info105_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info105_get_timeout(PyObject *obj, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(obj);
	PyObject *py_timeout;
	py_timeout = PyInt_FromLong(object->timeout);
	return py_timeout;
}

static int py_dfs_Info105_set_timeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timeout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info105_get_property_flag_mask(PyObject *obj, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(obj);
	PyObject *py_property_flag_mask;
	py_property_flag_mask = PyInt_FromLong(object->property_flag_mask);
	return py_property_flag_mask;
}

static int py_dfs_Info105_set_property_flag_mask(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->property_flag_mask = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_Info105_get_property_flags(PyObject *obj, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(obj);
	PyObject *py_property_flags;
	py_property_flags = PyInt_FromLong(object->property_flags);
	return py_property_flags;
}

static int py_dfs_Info105_set_property_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info105 *object = (struct dfs_Info105 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->property_flags = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_dfs_Info105_getsetters[] = {
	{ discard_const_p(char, "comment"), py_dfs_Info105_get_comment, py_dfs_Info105_set_comment },
	{ discard_const_p(char, "state"), py_dfs_Info105_get_state, py_dfs_Info105_set_state },
	{ discard_const_p(char, "timeout"), py_dfs_Info105_get_timeout, py_dfs_Info105_set_timeout },
	{ discard_const_p(char, "property_flag_mask"), py_dfs_Info105_get_property_flag_mask, py_dfs_Info105_set_property_flag_mask },
	{ discard_const_p(char, "property_flags"), py_dfs_Info105_get_property_flags, py_dfs_Info105_set_property_flags },
	{ NULL }
};

static PyObject *py_dfs_Info105_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info105, type);
}


static PyTypeObject dfs_Info105_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info105",
	.tp_getset = py_dfs_Info105_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info105_new,
};


static PyObject *py_dfs_Info106_get_state(PyObject *obj, void *closure)
{
	struct dfs_Info106 *object = (struct dfs_Info106 *)py_talloc_get_ptr(obj);
	PyObject *py_state;
	py_state = PyInt_FromLong(object->state);
	return py_state;
}

static int py_dfs_Info106_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info106 *object = (struct dfs_Info106 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->state = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->state = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info106_get_priority(PyObject *obj, void *closure)
{
	struct dfs_Info106 *object = (struct dfs_Info106 *)py_talloc_get_ptr(obj);
	PyObject *py_priority;
	py_priority = py_talloc_reference_ex(&dfs_Target_Priority_Type, py_talloc_get_mem_ctx(obj), &object->priority);
	return py_priority;
}

static int py_dfs_Info106_set_priority(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info106 *object = (struct dfs_Info106 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&dfs_Target_Priority_Type, value, return -1;);
	if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->priority = *(struct dfs_Target_Priority *)py_talloc_get_ptr(value);
	return 0;
}

static PyGetSetDef py_dfs_Info106_getsetters[] = {
	{ discard_const_p(char, "state"), py_dfs_Info106_get_state, py_dfs_Info106_set_state },
	{ discard_const_p(char, "priority"), py_dfs_Info106_get_priority, py_dfs_Info106_set_priority },
	{ NULL }
};

static PyObject *py_dfs_Info106_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info106, type);
}


static PyTypeObject dfs_Info106_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info106",
	.tp_getset = py_dfs_Info106_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info106_new,
};


static PyObject *py_dfs_Info200_get_dom_root(PyObject *obj, void *closure)
{
	struct dfs_Info200 *object = (struct dfs_Info200 *)py_talloc_get_ptr(obj);
	PyObject *py_dom_root;
	if (object->dom_root == NULL) {
		py_dom_root = Py_None;
		Py_INCREF(py_dom_root);
	} else {
		if (object->dom_root == NULL) {
			py_dom_root = Py_None;
			Py_INCREF(py_dom_root);
		} else {
			py_dom_root = PyUnicode_Decode(object->dom_root, strlen(object->dom_root), "utf-8", "ignore");
		}
	}
	return py_dom_root;
}

static int py_dfs_Info200_set_dom_root(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info200 *object = (struct dfs_Info200 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->dom_root = NULL;
	} else {
		object->dom_root = NULL;
		if (PyUnicode_Check(value)) {
			object->dom_root = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->dom_root = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info200_getsetters[] = {
	{ discard_const_p(char, "dom_root"), py_dfs_Info200_get_dom_root, py_dfs_Info200_set_dom_root },
	{ NULL }
};

static PyObject *py_dfs_Info200_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info200, type);
}


static PyTypeObject dfs_Info200_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info200",
	.tp_getset = py_dfs_Info200_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info200_new,
};


static PyObject *py_dfs_Info300_get_flavor(PyObject *obj, void *closure)
{
	struct dfs_Info300 *object = (struct dfs_Info300 *)py_talloc_get_ptr(obj);
	PyObject *py_flavor;
	py_flavor = PyInt_FromLong(object->flavor);
	return py_flavor;
}

static int py_dfs_Info300_set_flavor(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info300 *object = (struct dfs_Info300 *)py_talloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->flavor = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->flavor = PyInt_AsLong(value);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return -1;
	}
	return 0;
}

static PyObject *py_dfs_Info300_get_dom_root(PyObject *obj, void *closure)
{
	struct dfs_Info300 *object = (struct dfs_Info300 *)py_talloc_get_ptr(obj);
	PyObject *py_dom_root;
	if (object->dom_root == NULL) {
		py_dom_root = Py_None;
		Py_INCREF(py_dom_root);
	} else {
		if (object->dom_root == NULL) {
			py_dom_root = Py_None;
			Py_INCREF(py_dom_root);
		} else {
			py_dom_root = PyUnicode_Decode(object->dom_root, strlen(object->dom_root), "utf-8", "ignore");
		}
	}
	return py_dom_root;
}

static int py_dfs_Info300_set_dom_root(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_Info300 *object = (struct dfs_Info300 *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->dom_root = NULL;
	} else {
		object->dom_root = NULL;
		if (PyUnicode_Check(value)) {
			object->dom_root = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->dom_root = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_Info300_getsetters[] = {
	{ discard_const_p(char, "flavor"), py_dfs_Info300_get_flavor, py_dfs_Info300_set_flavor },
	{ discard_const_p(char, "dom_root"), py_dfs_Info300_get_dom_root, py_dfs_Info300_set_dom_root },
	{ NULL }
};

static PyObject *py_dfs_Info300_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_Info300, type);
}


static PyTypeObject dfs_Info300_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.Info300",
	.tp_getset = py_dfs_Info300_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_Info300_new,
};

PyObject *py_import_dfs_Info(TALLOC_CTX *mem_ctx, int level, union dfs_Info *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->info0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info0_Type, in->info0, in->info0);
			}
			return ret;

		case 1:
			if (in->info1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info1_Type, in->info1, in->info1);
			}
			return ret;

		case 2:
			if (in->info2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info2_Type, in->info2, in->info2);
			}
			return ret;

		case 3:
			if (in->info3 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info3_Type, in->info3, in->info3);
			}
			return ret;

		case 4:
			if (in->info4 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info4_Type, in->info4, in->info4);
			}
			return ret;

		case 5:
			if (in->info5 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info5_Type, in->info5, in->info5);
			}
			return ret;

		case 6:
			if (in->info6 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info6_Type, in->info6, in->info6);
			}
			return ret;

		case 7:
			if (in->info7 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info7_Type, in->info7, in->info7);
			}
			return ret;

		case 100:
			if (in->info100 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info100_Type, in->info100, in->info100);
			}
			return ret;

		case 101:
			if (in->info101 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info101_Type, in->info101, in->info101);
			}
			return ret;

		case 102:
			if (in->info102 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info102_Type, in->info102, in->info102);
			}
			return ret;

		case 103:
			if (in->info103 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info103_Type, in->info103, in->info103);
			}
			return ret;

		case 104:
			if (in->info104 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info104_Type, in->info104, in->info104);
			}
			return ret;

		case 105:
			if (in->info105 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info105_Type, in->info105, in->info105);
			}
			return ret;

		case 106:
			if (in->info106 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_Info106_Type, in->info106, in->info106);
			}
			return ret;

	}
	PyErr_SetString(PyExc_TypeError, "unknown union level");
	return NULL;
}

union dfs_Info *py_export_dfs_Info(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union dfs_Info *ret = talloc_zero(mem_ctx, union dfs_Info);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->info0 = NULL;
			} else {
				ret->info0 = NULL;
				PY_CHECK_TYPE(&dfs_Info0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info0 = (struct dfs_Info0 *)py_talloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&dfs_Info1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1 = (struct dfs_Info1 *)py_talloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->info2 = NULL;
			} else {
				ret->info2 = NULL;
				PY_CHECK_TYPE(&dfs_Info2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info2 = (struct dfs_Info2 *)py_talloc_get_ptr(in);
			}
			break;

		case 3:
			if (in == Py_None) {
				ret->info3 = NULL;
			} else {
				ret->info3 = NULL;
				PY_CHECK_TYPE(&dfs_Info3_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info3 = (struct dfs_Info3 *)py_talloc_get_ptr(in);
			}
			break;

		case 4:
			if (in == Py_None) {
				ret->info4 = NULL;
			} else {
				ret->info4 = NULL;
				PY_CHECK_TYPE(&dfs_Info4_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info4 = (struct dfs_Info4 *)py_talloc_get_ptr(in);
			}
			break;

		case 5:
			if (in == Py_None) {
				ret->info5 = NULL;
			} else {
				ret->info5 = NULL;
				PY_CHECK_TYPE(&dfs_Info5_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info5 = (struct dfs_Info5 *)py_talloc_get_ptr(in);
			}
			break;

		case 6:
			if (in == Py_None) {
				ret->info6 = NULL;
			} else {
				ret->info6 = NULL;
				PY_CHECK_TYPE(&dfs_Info6_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info6 = (struct dfs_Info6 *)py_talloc_get_ptr(in);
			}
			break;

		case 7:
			if (in == Py_None) {
				ret->info7 = NULL;
			} else {
				ret->info7 = NULL;
				PY_CHECK_TYPE(&dfs_Info7_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info7 = (struct dfs_Info7 *)py_talloc_get_ptr(in);
			}
			break;

		case 100:
			if (in == Py_None) {
				ret->info100 = NULL;
			} else {
				ret->info100 = NULL;
				PY_CHECK_TYPE(&dfs_Info100_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info100 = (struct dfs_Info100 *)py_talloc_get_ptr(in);
			}
			break;

		case 101:
			if (in == Py_None) {
				ret->info101 = NULL;
			} else {
				ret->info101 = NULL;
				PY_CHECK_TYPE(&dfs_Info101_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info101 = (struct dfs_Info101 *)py_talloc_get_ptr(in);
			}
			break;

		case 102:
			if (in == Py_None) {
				ret->info102 = NULL;
			} else {
				ret->info102 = NULL;
				PY_CHECK_TYPE(&dfs_Info102_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info102 = (struct dfs_Info102 *)py_talloc_get_ptr(in);
			}
			break;

		case 103:
			if (in == Py_None) {
				ret->info103 = NULL;
			} else {
				ret->info103 = NULL;
				PY_CHECK_TYPE(&dfs_Info103_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info103 = (struct dfs_Info103 *)py_talloc_get_ptr(in);
			}
			break;

		case 104:
			if (in == Py_None) {
				ret->info104 = NULL;
			} else {
				ret->info104 = NULL;
				PY_CHECK_TYPE(&dfs_Info104_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info104 = (struct dfs_Info104 *)py_talloc_get_ptr(in);
			}
			break;

		case 105:
			if (in == Py_None) {
				ret->info105 = NULL;
			} else {
				ret->info105 = NULL;
				PY_CHECK_TYPE(&dfs_Info105_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info105 = (struct dfs_Info105 *)py_talloc_get_ptr(in);
			}
			break;

		case 106:
			if (in == Py_None) {
				ret->info106 = NULL;
			} else {
				ret->info106 = NULL;
				PY_CHECK_TYPE(&dfs_Info106_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info106 = (struct dfs_Info106 *)py_talloc_get_ptr(in);
			}
			break;

		default:
			PyErr_SetString(PyExc_TypeError, "invalid union level value");
			talloc_free(ret);
			ret = NULL;
	}

	return ret;
}


static PyObject *py_dfs_EnumArray1_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray1 *object = (struct dfs_EnumArray1 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray1_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray1 *object = (struct dfs_EnumArray1 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray1_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray1 *object = (struct dfs_EnumArray1 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info1_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray1_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray1 *object = (struct dfs_EnumArray1 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info1_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info1 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray1_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray1_get_count, py_dfs_EnumArray1_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray1_get_s, py_dfs_EnumArray1_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray1, type);
}


static PyTypeObject dfs_EnumArray1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray1",
	.tp_getset = py_dfs_EnumArray1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray1_new,
};


static PyObject *py_dfs_EnumArray2_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray2 *object = (struct dfs_EnumArray2 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray2_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray2 *object = (struct dfs_EnumArray2 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray2_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray2 *object = (struct dfs_EnumArray2 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info2_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray2_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray2 *object = (struct dfs_EnumArray2 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info2_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info2 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray2_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray2_get_count, py_dfs_EnumArray2_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray2_get_s, py_dfs_EnumArray2_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray2, type);
}


static PyTypeObject dfs_EnumArray2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray2",
	.tp_getset = py_dfs_EnumArray2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray2_new,
};


static PyObject *py_dfs_EnumArray3_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray3 *object = (struct dfs_EnumArray3 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray3_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray3 *object = (struct dfs_EnumArray3 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray3_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray3 *object = (struct dfs_EnumArray3 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info3_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray3_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray3 *object = (struct dfs_EnumArray3 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info3_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info3 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray3_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray3_get_count, py_dfs_EnumArray3_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray3_get_s, py_dfs_EnumArray3_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray3, type);
}


static PyTypeObject dfs_EnumArray3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray3",
	.tp_getset = py_dfs_EnumArray3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray3_new,
};


static PyObject *py_dfs_EnumArray4_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray4 *object = (struct dfs_EnumArray4 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray4_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray4 *object = (struct dfs_EnumArray4 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray4_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray4 *object = (struct dfs_EnumArray4 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info4_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray4_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray4 *object = (struct dfs_EnumArray4 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info4_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info4 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray4_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray4_get_count, py_dfs_EnumArray4_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray4_get_s, py_dfs_EnumArray4_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray4_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray4, type);
}


static PyTypeObject dfs_EnumArray4_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray4",
	.tp_getset = py_dfs_EnumArray4_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray4_new,
};


static PyObject *py_dfs_EnumArray5_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray5 *object = (struct dfs_EnumArray5 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray5_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray5 *object = (struct dfs_EnumArray5 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray5_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray5 *object = (struct dfs_EnumArray5 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info5_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray5_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray5 *object = (struct dfs_EnumArray5 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info5_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info5 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray5_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray5_get_count, py_dfs_EnumArray5_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray5_get_s, py_dfs_EnumArray5_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray5_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray5, type);
}


static PyTypeObject dfs_EnumArray5_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray5",
	.tp_getset = py_dfs_EnumArray5_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray5_new,
};


static PyObject *py_dfs_EnumArray6_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray6 *object = (struct dfs_EnumArray6 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray6_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray6 *object = (struct dfs_EnumArray6 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray6_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray6 *object = (struct dfs_EnumArray6 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info6_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray6_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray6 *object = (struct dfs_EnumArray6 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info6_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info6 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray6_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray6_get_count, py_dfs_EnumArray6_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray6_get_s, py_dfs_EnumArray6_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray6_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray6, type);
}


static PyTypeObject dfs_EnumArray6_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray6",
	.tp_getset = py_dfs_EnumArray6_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray6_new,
};


static PyObject *py_dfs_EnumArray200_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray200 *object = (struct dfs_EnumArray200 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray200_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray200 *object = (struct dfs_EnumArray200 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray200_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray200 *object = (struct dfs_EnumArray200 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info200_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray200_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray200 *object = (struct dfs_EnumArray200 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info200_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info200 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray200_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray200_get_count, py_dfs_EnumArray200_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray200_get_s, py_dfs_EnumArray200_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray200_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray200, type);
}


static PyTypeObject dfs_EnumArray200_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray200",
	.tp_getset = py_dfs_EnumArray200_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray200_new,
};


static PyObject *py_dfs_EnumArray300_get_count(PyObject *obj, void *closure)
{
	struct dfs_EnumArray300 *object = (struct dfs_EnumArray300 *)py_talloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

static int py_dfs_EnumArray300_set_count(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray300 *object = (struct dfs_EnumArray300 *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->count = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumArray300_get_s(PyObject *obj, void *closure)
{
	struct dfs_EnumArray300 *object = (struct dfs_EnumArray300 *)py_talloc_get_ptr(obj);
	PyObject *py_s;
	if (object->s == NULL) {
		py_s = Py_None;
		Py_INCREF(py_s);
	} else {
		py_s = PyList_New(object->count);
		if (py_s == NULL) {
			return NULL;
		}
		{
			int s_cntr_1;
			for (s_cntr_1 = 0; s_cntr_1 < object->count; s_cntr_1++) {
				PyObject *py_s_1;
				py_s_1 = py_talloc_reference_ex(&dfs_Info300_Type, object->s, &object->s[s_cntr_1]);
				PyList_SetItem(py_s, s_cntr_1, py_s_1);
			}
		}
	}
	return py_s;
}

static int py_dfs_EnumArray300_set_s(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumArray300 *object = (struct dfs_EnumArray300 *)py_talloc_get_ptr(py_obj);
	talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->s);
	if (value == Py_None) {
		object->s = NULL;
	} else {
		object->s = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int s_cntr_1;
			object->s = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->s, PyList_GET_SIZE(value));
			if (!object->s) { return -1;; }
			talloc_set_name_const(object->s, "ARRAY: object->s");
			for (s_cntr_1 = 0; s_cntr_1 < PyList_GET_SIZE(value); s_cntr_1++) {
				PY_CHECK_TYPE(&dfs_Info300_Type, PyList_GET_ITEM(value, s_cntr_1), return -1;);
				if (talloc_reference(object->s, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, s_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->s[s_cntr_1] = *(struct dfs_Info300 *)py_talloc_get_ptr(PyList_GET_ITEM(value, s_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumArray300_getsetters[] = {
	{ discard_const_p(char, "count"), py_dfs_EnumArray300_get_count, py_dfs_EnumArray300_set_count },
	{ discard_const_p(char, "s"), py_dfs_EnumArray300_get_s, py_dfs_EnumArray300_set_s },
	{ NULL }
};

static PyObject *py_dfs_EnumArray300_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumArray300, type);
}


static PyTypeObject dfs_EnumArray300_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumArray300",
	.tp_getset = py_dfs_EnumArray300_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumArray300_new,
};

PyObject *py_import_dfs_EnumInfo(TALLOC_CTX *mem_ctx, int level, union dfs_EnumInfo *in)
{
	PyObject *ret;

	switch (level) {
		case 1:
			if (in->info1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray1_Type, in->info1, in->info1);
			}
			return ret;

		case 2:
			if (in->info2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray2_Type, in->info2, in->info2);
			}
			return ret;

		case 3:
			if (in->info3 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray3_Type, in->info3, in->info3);
			}
			return ret;

		case 4:
			if (in->info4 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray4_Type, in->info4, in->info4);
			}
			return ret;

		case 5:
			if (in->info5 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray5_Type, in->info5, in->info5);
			}
			return ret;

		case 6:
			if (in->info6 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray6_Type, in->info6, in->info6);
			}
			return ret;

		case 200:
			if (in->info200 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray200_Type, in->info200, in->info200);
			}
			return ret;

		case 300:
			if (in->info300 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = py_talloc_reference_ex(&dfs_EnumArray300_Type, in->info300, in->info300);
			}
			return ret;

	}
	PyErr_SetString(PyExc_TypeError, "unknown union level");
	return NULL;
}

union dfs_EnumInfo *py_export_dfs_EnumInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union dfs_EnumInfo *ret = talloc_zero(mem_ctx, union dfs_EnumInfo);
	switch (level) {
		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1 = (struct dfs_EnumArray1 *)py_talloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->info2 = NULL;
			} else {
				ret->info2 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info2 = (struct dfs_EnumArray2 *)py_talloc_get_ptr(in);
			}
			break;

		case 3:
			if (in == Py_None) {
				ret->info3 = NULL;
			} else {
				ret->info3 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray3_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info3 = (struct dfs_EnumArray3 *)py_talloc_get_ptr(in);
			}
			break;

		case 4:
			if (in == Py_None) {
				ret->info4 = NULL;
			} else {
				ret->info4 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray4_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info4 = (struct dfs_EnumArray4 *)py_talloc_get_ptr(in);
			}
			break;

		case 5:
			if (in == Py_None) {
				ret->info5 = NULL;
			} else {
				ret->info5 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray5_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info5 = (struct dfs_EnumArray5 *)py_talloc_get_ptr(in);
			}
			break;

		case 6:
			if (in == Py_None) {
				ret->info6 = NULL;
			} else {
				ret->info6 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray6_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info6 = (struct dfs_EnumArray6 *)py_talloc_get_ptr(in);
			}
			break;

		case 200:
			if (in == Py_None) {
				ret->info200 = NULL;
			} else {
				ret->info200 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray200_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info200 = (struct dfs_EnumArray200 *)py_talloc_get_ptr(in);
			}
			break;

		case 300:
			if (in == Py_None) {
				ret->info300 = NULL;
			} else {
				ret->info300 = NULL;
				PY_CHECK_TYPE(&dfs_EnumArray300_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, py_talloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info300 = (struct dfs_EnumArray300 *)py_talloc_get_ptr(in);
			}
			break;

		default:
			PyErr_SetString(PyExc_TypeError, "invalid union level value");
			talloc_free(ret);
			ret = NULL;
	}

	return ret;
}


static PyObject *py_dfs_EnumStruct_get_level(PyObject *obj, void *closure)
{
	struct dfs_EnumStruct *object = (struct dfs_EnumStruct *)py_talloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

static int py_dfs_EnumStruct_set_level(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumStruct *object = (struct dfs_EnumStruct *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->level = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_EnumStruct_get_e(PyObject *obj, void *closure)
{
	struct dfs_EnumStruct *object = (struct dfs_EnumStruct *)py_talloc_get_ptr(obj);
	PyObject *py_e;
	py_e = py_import_dfs_EnumInfo(py_talloc_get_mem_ctx(obj), object->level, &object->e);
	if (py_e == NULL) {
		return NULL;
	}
	return py_e;
}

static int py_dfs_EnumStruct_set_e(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_EnumStruct *object = (struct dfs_EnumStruct *)py_talloc_get_ptr(py_obj);
	{
		union dfs_EnumInfo *e_switch_0;
		e_switch_0 = py_export_dfs_EnumInfo(py_talloc_get_mem_ctx(py_obj), object->level, value);
		if (e_switch_0 == NULL) {
			return -1;
		}
		object->e = *e_switch_0;
	}
	return 0;
}

static PyGetSetDef py_dfs_EnumStruct_getsetters[] = {
	{ discard_const_p(char, "level"), py_dfs_EnumStruct_get_level, py_dfs_EnumStruct_set_level },
	{ discard_const_p(char, "e"), py_dfs_EnumStruct_get_e, py_dfs_EnumStruct_set_e },
	{ NULL }
};

static PyObject *py_dfs_EnumStruct_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_EnumStruct, type);
}


static PyTypeObject dfs_EnumStruct_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.EnumStruct",
	.tp_getset = py_dfs_EnumStruct_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_EnumStruct_new,
};


static PyObject *py_dfs_UnknownStruct_get_unknown1(PyObject *obj, void *closure)
{
	struct dfs_UnknownStruct *object = (struct dfs_UnknownStruct *)py_talloc_get_ptr(obj);
	PyObject *py_unknown1;
	py_unknown1 = PyInt_FromLong(object->unknown1);
	return py_unknown1;
}

static int py_dfs_UnknownStruct_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_UnknownStruct *object = (struct dfs_UnknownStruct *)py_talloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->unknown1 = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_dfs_UnknownStruct_get_unknown2(PyObject *obj, void *closure)
{
	struct dfs_UnknownStruct *object = (struct dfs_UnknownStruct *)py_talloc_get_ptr(obj);
	PyObject *py_unknown2;
	if (object->unknown2 == NULL) {
		py_unknown2 = Py_None;
		Py_INCREF(py_unknown2);
	} else {
		if (object->unknown2 == NULL) {
			py_unknown2 = Py_None;
			Py_INCREF(py_unknown2);
		} else {
			py_unknown2 = PyUnicode_Decode(object->unknown2, strlen(object->unknown2), "utf-8", "ignore");
		}
	}
	return py_unknown2;
}

static int py_dfs_UnknownStruct_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct dfs_UnknownStruct *object = (struct dfs_UnknownStruct *)py_talloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->unknown2 = NULL;
	} else {
		object->unknown2 = NULL;
		if (PyUnicode_Check(value)) {
			object->unknown2 = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->unknown2 = PyString_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_dfs_UnknownStruct_getsetters[] = {
	{ discard_const_p(char, "unknown1"), py_dfs_UnknownStruct_get_unknown1, py_dfs_UnknownStruct_set_unknown1 },
	{ discard_const_p(char, "unknown2"), py_dfs_UnknownStruct_get_unknown2, py_dfs_UnknownStruct_set_unknown2 },
	{ NULL }
};

static PyObject *py_dfs_UnknownStruct_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_talloc_new(struct dfs_UnknownStruct, type);
}


static PyTypeObject dfs_UnknownStruct_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.UnknownStruct",
	.tp_getset = py_dfs_UnknownStruct_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(py_talloc_Object),
	.tp_new = py_dfs_UnknownStruct_new,
};


static bool pack_py_dfs_GetManagerVersion_args_in(PyObject *args, PyObject *kwargs, struct dfs_GetManagerVersion *r)
{
	const char *kwnames[] = {
		NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":dfs_GetManagerVersion", discard_const_p(char *, kwnames))) {
		return false;
	}

	return true;
}

static PyObject *unpack_py_dfs_GetManagerVersion_args_out(struct dfs_GetManagerVersion *r)
{
	PyObject *result;
	PyObject *py_version;
	py_version = PyInt_FromLong(*r->out.version);
	result = py_version;
	return result;
}

static bool pack_py_dfs_Add_args_in(PyObject *args, PyObject *kwargs, struct dfs_Add *r)
{
	PyObject *py_path;
	PyObject *py_server;
	PyObject *py_share;
	PyObject *py_comment;
	PyObject *py_flags;
	const char *kwnames[] = {
		"path", "server", "share", "comment", "flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:dfs_Add", discard_const_p(char *, kwnames), &py_path, &py_server, &py_share, &py_comment, &py_flags)) {
		return false;
	}

	r->in.path = talloc_ptrtype(r, r->in.path);
	if (PyUnicode_Check(py_path)) {
		r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
	} else if (PyString_Check(py_path)) {
		r->in.path = PyString_AS_STRING(py_path);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
		return false;
	}
	r->in.server = talloc_ptrtype(r, r->in.server);
	if (PyUnicode_Check(py_server)) {
		r->in.server = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server, "utf-8", "ignore"));
	} else if (PyString_Check(py_server)) {
		r->in.server = PyString_AS_STRING(py_server);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server)->tp_name);
		return false;
	}
	if (py_share == Py_None) {
		r->in.share = NULL;
	} else {
		r->in.share = NULL;
		if (PyUnicode_Check(py_share)) {
			r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
		} else if (PyString_Check(py_share)) {
			r->in.share = PyString_AS_STRING(py_share);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
			return false;
		}
	}
	if (py_comment == Py_None) {
		r->in.comment = NULL;
	} else {
		r->in.comment = NULL;
		if (PyUnicode_Check(py_comment)) {
			r->in.comment = PyString_AS_STRING(PyUnicode_AsEncodedString(py_comment, "utf-8", "ignore"));
		} else if (PyString_Check(py_comment)) {
			r->in.comment = PyString_AS_STRING(py_comment);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_comment)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	return true;
}

static PyObject *unpack_py_dfs_Add_args_out(struct dfs_Add *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_Remove_args_in(PyObject *args, PyObject *kwargs, struct dfs_Remove *r)
{
	PyObject *py_dfs_entry_path;
	PyObject *py_servername;
	PyObject *py_sharename;
	const char *kwnames[] = {
		"dfs_entry_path", "servername", "sharename", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:dfs_Remove", discard_const_p(char *, kwnames), &py_dfs_entry_path, &py_servername, &py_sharename)) {
		return false;
	}

	r->in.dfs_entry_path = talloc_ptrtype(r, r->in.dfs_entry_path);
	if (PyUnicode_Check(py_dfs_entry_path)) {
		r->in.dfs_entry_path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfs_entry_path, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfs_entry_path)) {
		r->in.dfs_entry_path = PyString_AS_STRING(py_dfs_entry_path);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfs_entry_path)->tp_name);
		return false;
	}
	if (py_servername == Py_None) {
		r->in.servername = NULL;
	} else {
		r->in.servername = NULL;
		if (PyUnicode_Check(py_servername)) {
			r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
		} else if (PyString_Check(py_servername)) {
			r->in.servername = PyString_AS_STRING(py_servername);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
			return false;
		}
	}
	if (py_sharename == Py_None) {
		r->in.sharename = NULL;
	} else {
		r->in.sharename = NULL;
		if (PyUnicode_Check(py_sharename)) {
			r->in.sharename = PyString_AS_STRING(PyUnicode_AsEncodedString(py_sharename, "utf-8", "ignore"));
		} else if (PyString_Check(py_sharename)) {
			r->in.sharename = PyString_AS_STRING(py_sharename);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_sharename)->tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_dfs_Remove_args_out(struct dfs_Remove *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_SetInfo_args_in(PyObject *args, PyObject *kwargs, struct dfs_SetInfo *r)
{
	PyObject *py_dfs_entry_path;
	PyObject *py_servername;
	PyObject *py_sharename;
	PyObject *py_level;
	PyObject *py_info;
	const char *kwnames[] = {
		"dfs_entry_path", "servername", "sharename", "level", "info", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:dfs_SetInfo", discard_const_p(char *, kwnames), &py_dfs_entry_path, &py_servername, &py_sharename, &py_level, &py_info)) {
		return false;
	}

	if (PyUnicode_Check(py_dfs_entry_path)) {
		r->in.dfs_entry_path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfs_entry_path, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfs_entry_path)) {
		r->in.dfs_entry_path = PyString_AS_STRING(py_dfs_entry_path);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfs_entry_path)->tp_name);
		return false;
	}
	if (py_servername == Py_None) {
		r->in.servername = NULL;
	} else {
		r->in.servername = NULL;
		if (PyUnicode_Check(py_servername)) {
			r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
		} else if (PyString_Check(py_servername)) {
			r->in.servername = PyString_AS_STRING(py_servername);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
			return false;
		}
	}
	if (py_sharename == Py_None) {
		r->in.sharename = NULL;
	} else {
		r->in.sharename = NULL;
		if (PyUnicode_Check(py_sharename)) {
			r->in.sharename = PyString_AS_STRING(PyUnicode_AsEncodedString(py_sharename, "utf-8", "ignore"));
		} else if (PyString_Check(py_sharename)) {
			r->in.sharename = PyString_AS_STRING(py_sharename);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_sharename)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	r->in.info = talloc_ptrtype(r, r->in.info);
	{
		union dfs_Info *info_switch_1;
		info_switch_1 = py_export_dfs_Info(r, r->in.level, py_info);
		if (info_switch_1 == NULL) {
			return false;
		}
		r->in.info = info_switch_1;
	}
	return true;
}

static PyObject *unpack_py_dfs_SetInfo_args_out(struct dfs_SetInfo *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_GetInfo_args_in(PyObject *args, PyObject *kwargs, struct dfs_GetInfo *r)
{
	PyObject *py_dfs_entry_path;
	PyObject *py_servername;
	PyObject *py_sharename;
	PyObject *py_level;
	const char *kwnames[] = {
		"dfs_entry_path", "servername", "sharename", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dfs_GetInfo", discard_const_p(char *, kwnames), &py_dfs_entry_path, &py_servername, &py_sharename, &py_level)) {
		return false;
	}

	if (PyUnicode_Check(py_dfs_entry_path)) {
		r->in.dfs_entry_path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfs_entry_path, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfs_entry_path)) {
		r->in.dfs_entry_path = PyString_AS_STRING(py_dfs_entry_path);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfs_entry_path)->tp_name);
		return false;
	}
	if (py_servername == Py_None) {
		r->in.servername = NULL;
	} else {
		r->in.servername = NULL;
		if (PyUnicode_Check(py_servername)) {
			r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
		} else if (PyString_Check(py_servername)) {
			r->in.servername = PyString_AS_STRING(py_servername);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
			return false;
		}
	}
	if (py_sharename == Py_None) {
		r->in.sharename = NULL;
	} else {
		r->in.sharename = NULL;
		if (PyUnicode_Check(py_sharename)) {
			r->in.sharename = PyString_AS_STRING(PyUnicode_AsEncodedString(py_sharename, "utf-8", "ignore"));
		} else if (PyString_Check(py_sharename)) {
			r->in.sharename = PyString_AS_STRING(py_sharename);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_sharename)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	return true;
}

static PyObject *unpack_py_dfs_GetInfo_args_out(struct dfs_GetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_dfs_Info(r->out.info, r->in.level, r->out.info);
	if (py_info == NULL) {
		return NULL;
	}
	result = py_info;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_Enum_args_in(PyObject *args, PyObject *kwargs, struct dfs_Enum *r)
{
	PyObject *py_level;
	PyObject *py_bufsize;
	PyObject *py_info;
	PyObject *py_total;
	const char *kwnames[] = {
		"level", "bufsize", "info", "total", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dfs_Enum", discard_const_p(char *, kwnames), &py_level, &py_bufsize, &py_info, &py_total)) {
		return false;
	}

	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	PY_CHECK_TYPE(&PyInt_Type, py_bufsize, return false;);
	r->in.bufsize = PyInt_AsLong(py_bufsize);
	if (py_info == Py_None) {
		r->in.info = NULL;
	} else {
		r->in.info = NULL;
		PY_CHECK_TYPE(&dfs_EnumStruct_Type, py_info, return false;);
		if (talloc_reference(r, py_talloc_get_mem_ctx(py_info)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.info = (struct dfs_EnumStruct *)py_talloc_get_ptr(py_info);
	}
	if (py_total == Py_None) {
		r->in.total = NULL;
	} else {
		r->in.total = talloc_ptrtype(r, r->in.total);
		PY_CHECK_TYPE(&PyInt_Type, py_total, return false;);
		*r->in.total = PyInt_AsLong(py_total);
	}
	return true;
}

static PyObject *unpack_py_dfs_Enum_args_out(struct dfs_Enum *r)
{
	PyObject *result;
	PyObject *py_info;
	PyObject *py_total;
	result = PyTuple_New(2);
	if (r->out.info == NULL) {
		py_info = Py_None;
		Py_INCREF(py_info);
	} else {
		py_info = py_talloc_reference_ex(&dfs_EnumStruct_Type, r->out.info, r->out.info);
	}
	PyTuple_SetItem(result, 0, py_info);
	if (r->out.total == NULL) {
		py_total = Py_None;
		Py_INCREF(py_total);
	} else {
		py_total = PyInt_FromLong(*r->out.total);
	}
	PyTuple_SetItem(result, 1, py_total);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_AddFtRoot_args_in(PyObject *args, PyObject *kwargs, struct dfs_AddFtRoot *r)
{
	PyObject *py_servername;
	PyObject *py_dns_servername;
	PyObject *py_dfsname;
	PyObject *py_rootshare;
	PyObject *py_comment;
	PyObject *py_dfs_config_dn;
	PyObject *py_unknown1;
	PyObject *py_flags;
	PyObject *py_unknown2;
	const char *kwnames[] = {
		"servername", "dns_servername", "dfsname", "rootshare", "comment", "dfs_config_dn", "unknown1", "flags", "unknown2", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO:dfs_AddFtRoot", discard_const_p(char *, kwnames), &py_servername, &py_dns_servername, &py_dfsname, &py_rootshare, &py_comment, &py_dfs_config_dn, &py_unknown1, &py_flags, &py_unknown2)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_dns_servername)) {
		r->in.dns_servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dns_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_dns_servername)) {
		r->in.dns_servername = PyString_AS_STRING(py_dns_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dns_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_dfsname)) {
		r->in.dfsname = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfsname, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfsname)) {
		r->in.dfsname = PyString_AS_STRING(py_dfsname);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfsname)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(PyUnicode_AsEncodedString(py_rootshare, "utf-8", "ignore"));
	} else if (PyString_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(py_rootshare);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_rootshare)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_comment)) {
		r->in.comment = PyString_AS_STRING(PyUnicode_AsEncodedString(py_comment, "utf-8", "ignore"));
	} else if (PyString_Check(py_comment)) {
		r->in.comment = PyString_AS_STRING(py_comment);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_comment)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_dfs_config_dn)) {
		r->in.dfs_config_dn = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfs_config_dn, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfs_config_dn)) {
		r->in.dfs_config_dn = PyString_AS_STRING(py_dfs_config_dn);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfs_config_dn)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_unknown1, return false;);
	r->in.unknown1 = PyInt_AsLong(py_unknown1);
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	if (py_unknown2 == Py_None) {
		r->in.unknown2 = NULL;
	} else {
		r->in.unknown2 = NULL;
		if (py_unknown2 == Py_None) {
			*r->in.unknown2 = NULL;
		} else {
			*r->in.unknown2 = NULL;
			PY_CHECK_TYPE(&dfs_UnknownStruct_Type, py_unknown2, return false;);
			if (talloc_reference(r, py_talloc_get_mem_ctx(py_unknown2)) == NULL) {
				PyErr_NoMemory();
				return false;
			}
			*r->in.unknown2 = (struct dfs_UnknownStruct *)py_talloc_get_ptr(py_unknown2);
		}
	}
	return true;
}

static PyObject *unpack_py_dfs_AddFtRoot_args_out(struct dfs_AddFtRoot *r)
{
	PyObject *result;
	PyObject *py_unknown2;
	if (r->out.unknown2 == NULL) {
		py_unknown2 = Py_None;
		Py_INCREF(py_unknown2);
	} else {
		if (*r->out.unknown2 == NULL) {
			py_unknown2 = Py_None;
			Py_INCREF(py_unknown2);
		} else {
			py_unknown2 = py_talloc_reference_ex(&dfs_UnknownStruct_Type, *r->out.unknown2, *r->out.unknown2);
		}
	}
	result = py_unknown2;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_RemoveFtRoot_args_in(PyObject *args, PyObject *kwargs, struct dfs_RemoveFtRoot *r)
{
	PyObject *py_servername;
	PyObject *py_dns_servername;
	PyObject *py_dfsname;
	PyObject *py_rootshare;
	PyObject *py_flags;
	PyObject *py_unknown;
	const char *kwnames[] = {
		"servername", "dns_servername", "dfsname", "rootshare", "flags", "unknown", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:dfs_RemoveFtRoot", discard_const_p(char *, kwnames), &py_servername, &py_dns_servername, &py_dfsname, &py_rootshare, &py_flags, &py_unknown)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_dns_servername)) {
		r->in.dns_servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dns_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_dns_servername)) {
		r->in.dns_servername = PyString_AS_STRING(py_dns_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dns_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_dfsname)) {
		r->in.dfsname = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfsname, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfsname)) {
		r->in.dfsname = PyString_AS_STRING(py_dfsname);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfsname)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(PyUnicode_AsEncodedString(py_rootshare, "utf-8", "ignore"));
	} else if (PyString_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(py_rootshare);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_rootshare)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	if (py_unknown == Py_None) {
		r->in.unknown = NULL;
	} else {
		r->in.unknown = NULL;
		if (py_unknown == Py_None) {
			*r->in.unknown = NULL;
		} else {
			*r->in.unknown = NULL;
			PY_CHECK_TYPE(&dfs_UnknownStruct_Type, py_unknown, return false;);
			if (talloc_reference(r, py_talloc_get_mem_ctx(py_unknown)) == NULL) {
				PyErr_NoMemory();
				return false;
			}
			*r->in.unknown = (struct dfs_UnknownStruct *)py_talloc_get_ptr(py_unknown);
		}
	}
	return true;
}

static PyObject *unpack_py_dfs_RemoveFtRoot_args_out(struct dfs_RemoveFtRoot *r)
{
	PyObject *result;
	PyObject *py_unknown;
	if (r->out.unknown == NULL) {
		py_unknown = Py_None;
		Py_INCREF(py_unknown);
	} else {
		if (*r->out.unknown == NULL) {
			py_unknown = Py_None;
			Py_INCREF(py_unknown);
		} else {
			py_unknown = py_talloc_reference_ex(&dfs_UnknownStruct_Type, *r->out.unknown, *r->out.unknown);
		}
	}
	result = py_unknown;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_AddStdRoot_args_in(PyObject *args, PyObject *kwargs, struct dfs_AddStdRoot *r)
{
	PyObject *py_servername;
	PyObject *py_rootshare;
	PyObject *py_comment;
	PyObject *py_flags;
	const char *kwnames[] = {
		"servername", "rootshare", "comment", "flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dfs_AddStdRoot", discard_const_p(char *, kwnames), &py_servername, &py_rootshare, &py_comment, &py_flags)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(PyUnicode_AsEncodedString(py_rootshare, "utf-8", "ignore"));
	} else if (PyString_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(py_rootshare);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_rootshare)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_comment)) {
		r->in.comment = PyString_AS_STRING(PyUnicode_AsEncodedString(py_comment, "utf-8", "ignore"));
	} else if (PyString_Check(py_comment)) {
		r->in.comment = PyString_AS_STRING(py_comment);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_comment)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	return true;
}

static PyObject *unpack_py_dfs_AddStdRoot_args_out(struct dfs_AddStdRoot *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_RemoveStdRoot_args_in(PyObject *args, PyObject *kwargs, struct dfs_RemoveStdRoot *r)
{
	PyObject *py_servername;
	PyObject *py_rootshare;
	PyObject *py_flags;
	const char *kwnames[] = {
		"servername", "rootshare", "flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:dfs_RemoveStdRoot", discard_const_p(char *, kwnames), &py_servername, &py_rootshare, &py_flags)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(PyUnicode_AsEncodedString(py_rootshare, "utf-8", "ignore"));
	} else if (PyString_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(py_rootshare);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_rootshare)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	return true;
}

static PyObject *unpack_py_dfs_RemoveStdRoot_args_out(struct dfs_RemoveStdRoot *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_ManagerInitialize_args_in(PyObject *args, PyObject *kwargs, struct dfs_ManagerInitialize *r)
{
	PyObject *py_servername;
	PyObject *py_flags;
	const char *kwnames[] = {
		"servername", "flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:dfs_ManagerInitialize", discard_const_p(char *, kwnames), &py_servername, &py_flags)) {
		return false;
	}

	r->in.servername = talloc_ptrtype(r, r->in.servername);
	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	return true;
}

static PyObject *unpack_py_dfs_ManagerInitialize_args_out(struct dfs_ManagerInitialize *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_AddStdRootForced_args_in(PyObject *args, PyObject *kwargs, struct dfs_AddStdRootForced *r)
{
	PyObject *py_servername;
	PyObject *py_rootshare;
	PyObject *py_comment;
	PyObject *py_store;
	const char *kwnames[] = {
		"servername", "rootshare", "comment", "store", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dfs_AddStdRootForced", discard_const_p(char *, kwnames), &py_servername, &py_rootshare, &py_comment, &py_store)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(PyUnicode_AsEncodedString(py_rootshare, "utf-8", "ignore"));
	} else if (PyString_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(py_rootshare);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_rootshare)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_comment)) {
		r->in.comment = PyString_AS_STRING(PyUnicode_AsEncodedString(py_comment, "utf-8", "ignore"));
	} else if (PyString_Check(py_comment)) {
		r->in.comment = PyString_AS_STRING(py_comment);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_comment)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_store)) {
		r->in.store = PyString_AS_STRING(PyUnicode_AsEncodedString(py_store, "utf-8", "ignore"));
	} else if (PyString_Check(py_store)) {
		r->in.store = PyString_AS_STRING(py_store);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_store)->tp_name);
		return false;
	}
	return true;
}

static PyObject *unpack_py_dfs_AddStdRootForced_args_out(struct dfs_AddStdRootForced *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_GetDcAddress_args_in(PyObject *args, PyObject *kwargs, struct dfs_GetDcAddress *r)
{
	PyObject *py_servername;
	PyObject *py_server_fullname;
	PyObject *py_is_root;
	PyObject *py_ttl;
	const char *kwnames[] = {
		"servername", "server_fullname", "is_root", "ttl", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dfs_GetDcAddress", discard_const_p(char *, kwnames), &py_servername, &py_server_fullname, &py_is_root, &py_ttl)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	r->in.server_fullname = talloc_ptrtype(r, r->in.server_fullname);
	if (py_server_fullname == Py_None) {
		*r->in.server_fullname = NULL;
	} else {
		*r->in.server_fullname = NULL;
		if (PyUnicode_Check(py_server_fullname)) {
			*r->in.server_fullname = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_fullname, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_fullname)) {
			*r->in.server_fullname = PyString_AS_STRING(py_server_fullname);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_fullname)->tp_name);
			return false;
		}
	}
	r->in.is_root = talloc_ptrtype(r, r->in.is_root);
	PY_CHECK_TYPE(&PyInt_Type, py_is_root, return false;);
	*r->in.is_root = PyInt_AsLong(py_is_root);
	r->in.ttl = talloc_ptrtype(r, r->in.ttl);
	PY_CHECK_TYPE(&PyInt_Type, py_ttl, return false;);
	*r->in.ttl = PyInt_AsLong(py_ttl);
	return true;
}

static PyObject *unpack_py_dfs_GetDcAddress_args_out(struct dfs_GetDcAddress *r)
{
	PyObject *result;
	PyObject *py_server_fullname;
	PyObject *py_is_root;
	PyObject *py_ttl;
	result = PyTuple_New(3);
	if (*r->out.server_fullname == NULL) {
		py_server_fullname = Py_None;
		Py_INCREF(py_server_fullname);
	} else {
		if (*r->out.server_fullname == NULL) {
			py_server_fullname = Py_None;
			Py_INCREF(py_server_fullname);
		} else {
			py_server_fullname = PyUnicode_Decode(*r->out.server_fullname, strlen(*r->out.server_fullname), "utf-8", "ignore");
		}
	}
	PyTuple_SetItem(result, 0, py_server_fullname);
	py_is_root = PyInt_FromLong(*r->out.is_root);
	PyTuple_SetItem(result, 1, py_is_root);
	py_ttl = PyInt_FromLong(*r->out.ttl);
	PyTuple_SetItem(result, 2, py_ttl);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_SetDcAddress_args_in(PyObject *args, PyObject *kwargs, struct dfs_SetDcAddress *r)
{
	PyObject *py_servername;
	PyObject *py_server_fullname;
	PyObject *py_flags;
	PyObject *py_ttl;
	const char *kwnames[] = {
		"servername", "server_fullname", "flags", "ttl", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dfs_SetDcAddress", discard_const_p(char *, kwnames), &py_servername, &py_server_fullname, &py_flags, &py_ttl)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_server_fullname)) {
		r->in.server_fullname = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_fullname, "utf-8", "ignore"));
	} else if (PyString_Check(py_server_fullname)) {
		r->in.server_fullname = PyString_AS_STRING(py_server_fullname);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_fullname)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	PY_CHECK_TYPE(&PyInt_Type, py_ttl, return false;);
	r->in.ttl = PyInt_AsLong(py_ttl);
	return true;
}

static PyObject *unpack_py_dfs_SetDcAddress_args_out(struct dfs_SetDcAddress *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_FlushFtTable_args_in(PyObject *args, PyObject *kwargs, struct dfs_FlushFtTable *r)
{
	PyObject *py_servername;
	PyObject *py_rootshare;
	const char *kwnames[] = {
		"servername", "rootshare", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:dfs_FlushFtTable", discard_const_p(char *, kwnames), &py_servername, &py_rootshare)) {
		return false;
	}

	if (PyUnicode_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(PyUnicode_AsEncodedString(py_servername, "utf-8", "ignore"));
	} else if (PyString_Check(py_servername)) {
		r->in.servername = PyString_AS_STRING(py_servername);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_servername)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(PyUnicode_AsEncodedString(py_rootshare, "utf-8", "ignore"));
	} else if (PyString_Check(py_rootshare)) {
		r->in.rootshare = PyString_AS_STRING(py_rootshare);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_rootshare)->tp_name);
		return false;
	}
	return true;
}

static PyObject *unpack_py_dfs_FlushFtTable_args_out(struct dfs_FlushFtTable *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_dfs_EnumEx_args_in(PyObject *args, PyObject *kwargs, struct dfs_EnumEx *r)
{
	PyObject *py_dfs_name;
	PyObject *py_level;
	PyObject *py_bufsize;
	PyObject *py_info;
	PyObject *py_total;
	const char *kwnames[] = {
		"dfs_name", "level", "bufsize", "info", "total", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:dfs_EnumEx", discard_const_p(char *, kwnames), &py_dfs_name, &py_level, &py_bufsize, &py_info, &py_total)) {
		return false;
	}

	if (PyUnicode_Check(py_dfs_name)) {
		r->in.dfs_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_dfs_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_dfs_name)) {
		r->in.dfs_name = PyString_AS_STRING(py_dfs_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_dfs_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	PY_CHECK_TYPE(&PyInt_Type, py_bufsize, return false;);
	r->in.bufsize = PyInt_AsLong(py_bufsize);
	if (py_info == Py_None) {
		r->in.info = NULL;
	} else {
		r->in.info = NULL;
		PY_CHECK_TYPE(&dfs_EnumStruct_Type, py_info, return false;);
		if (talloc_reference(r, py_talloc_get_mem_ctx(py_info)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.info = (struct dfs_EnumStruct *)py_talloc_get_ptr(py_info);
	}
	if (py_total == Py_None) {
		r->in.total = NULL;
	} else {
		r->in.total = talloc_ptrtype(r, r->in.total);
		PY_CHECK_TYPE(&PyInt_Type, py_total, return false;);
		*r->in.total = PyInt_AsLong(py_total);
	}
	return true;
}

static PyObject *unpack_py_dfs_EnumEx_args_out(struct dfs_EnumEx *r)
{
	PyObject *result;
	PyObject *py_info;
	PyObject *py_total;
	result = PyTuple_New(2);
	if (r->out.info == NULL) {
		py_info = Py_None;
		Py_INCREF(py_info);
	} else {
		py_info = py_talloc_reference_ex(&dfs_EnumStruct_Type, r->out.info, r->out.info);
	}
	PyTuple_SetItem(result, 0, py_info);
	if (r->out.total == NULL) {
		py_total = Py_None;
		Py_INCREF(py_total);
	} else {
		py_total = PyInt_FromLong(*r->out.total);
	}
	PyTuple_SetItem(result, 1, py_total);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

const struct PyNdrRpcMethodDef py_ndr_netdfs_methods[] = {
	{ "GetManagerVersion", "S.GetManagerVersion() -> version", (py_dcerpc_call_fn)dcerpc_dfs_GetManagerVersion_r, (py_data_pack_fn)pack_py_dfs_GetManagerVersion_args_in, (py_data_unpack_fn)unpack_py_dfs_GetManagerVersion_args_out, 0, &ndr_table_netdfs },
	{ "Add", "S.Add(path, server, share, comment, flags) -> None", (py_dcerpc_call_fn)dcerpc_dfs_Add_r, (py_data_pack_fn)pack_py_dfs_Add_args_in, (py_data_unpack_fn)unpack_py_dfs_Add_args_out, 1, &ndr_table_netdfs },
	{ "Remove", "S.Remove(dfs_entry_path, servername, sharename) -> None", (py_dcerpc_call_fn)dcerpc_dfs_Remove_r, (py_data_pack_fn)pack_py_dfs_Remove_args_in, (py_data_unpack_fn)unpack_py_dfs_Remove_args_out, 2, &ndr_table_netdfs },
	{ "SetInfo", "S.SetInfo(dfs_entry_path, servername, sharename, level, info) -> None", (py_dcerpc_call_fn)dcerpc_dfs_SetInfo_r, (py_data_pack_fn)pack_py_dfs_SetInfo_args_in, (py_data_unpack_fn)unpack_py_dfs_SetInfo_args_out, 3, &ndr_table_netdfs },
	{ "GetInfo", "S.GetInfo(dfs_entry_path, servername, sharename, level) -> info", (py_dcerpc_call_fn)dcerpc_dfs_GetInfo_r, (py_data_pack_fn)pack_py_dfs_GetInfo_args_in, (py_data_unpack_fn)unpack_py_dfs_GetInfo_args_out, 4, &ndr_table_netdfs },
	{ "Enum", "S.Enum(level, bufsize, info, total) -> (info, total)", (py_dcerpc_call_fn)dcerpc_dfs_Enum_r, (py_data_pack_fn)pack_py_dfs_Enum_args_in, (py_data_unpack_fn)unpack_py_dfs_Enum_args_out, 5, &ndr_table_netdfs },
	{ "AddFtRoot", "S.AddFtRoot(servername, dns_servername, dfsname, rootshare, comment, dfs_config_dn, unknown1, flags, unknown2) -> unknown2", (py_dcerpc_call_fn)dcerpc_dfs_AddFtRoot_r, (py_data_pack_fn)pack_py_dfs_AddFtRoot_args_in, (py_data_unpack_fn)unpack_py_dfs_AddFtRoot_args_out, 10, &ndr_table_netdfs },
	{ "RemoveFtRoot", "S.RemoveFtRoot(servername, dns_servername, dfsname, rootshare, flags, unknown) -> unknown", (py_dcerpc_call_fn)dcerpc_dfs_RemoveFtRoot_r, (py_data_pack_fn)pack_py_dfs_RemoveFtRoot_args_in, (py_data_unpack_fn)unpack_py_dfs_RemoveFtRoot_args_out, 11, &ndr_table_netdfs },
	{ "AddStdRoot", "S.AddStdRoot(servername, rootshare, comment, flags) -> None", (py_dcerpc_call_fn)dcerpc_dfs_AddStdRoot_r, (py_data_pack_fn)pack_py_dfs_AddStdRoot_args_in, (py_data_unpack_fn)unpack_py_dfs_AddStdRoot_args_out, 12, &ndr_table_netdfs },
	{ "RemoveStdRoot", "S.RemoveStdRoot(servername, rootshare, flags) -> None", (py_dcerpc_call_fn)dcerpc_dfs_RemoveStdRoot_r, (py_data_pack_fn)pack_py_dfs_RemoveStdRoot_args_in, (py_data_unpack_fn)unpack_py_dfs_RemoveStdRoot_args_out, 13, &ndr_table_netdfs },
	{ "ManagerInitialize", "S.ManagerInitialize(servername, flags) -> None", (py_dcerpc_call_fn)dcerpc_dfs_ManagerInitialize_r, (py_data_pack_fn)pack_py_dfs_ManagerInitialize_args_in, (py_data_unpack_fn)unpack_py_dfs_ManagerInitialize_args_out, 14, &ndr_table_netdfs },
	{ "AddStdRootForced", "S.AddStdRootForced(servername, rootshare, comment, store) -> None", (py_dcerpc_call_fn)dcerpc_dfs_AddStdRootForced_r, (py_data_pack_fn)pack_py_dfs_AddStdRootForced_args_in, (py_data_unpack_fn)unpack_py_dfs_AddStdRootForced_args_out, 15, &ndr_table_netdfs },
	{ "GetDcAddress", "S.GetDcAddress(servername, server_fullname, is_root, ttl) -> (server_fullname, is_root, ttl)", (py_dcerpc_call_fn)dcerpc_dfs_GetDcAddress_r, (py_data_pack_fn)pack_py_dfs_GetDcAddress_args_in, (py_data_unpack_fn)unpack_py_dfs_GetDcAddress_args_out, 16, &ndr_table_netdfs },
	{ "SetDcAddress", "S.SetDcAddress(servername, server_fullname, flags, ttl) -> None", (py_dcerpc_call_fn)dcerpc_dfs_SetDcAddress_r, (py_data_pack_fn)pack_py_dfs_SetDcAddress_args_in, (py_data_unpack_fn)unpack_py_dfs_SetDcAddress_args_out, 17, &ndr_table_netdfs },
	{ "FlushFtTable", "S.FlushFtTable(servername, rootshare) -> None", (py_dcerpc_call_fn)dcerpc_dfs_FlushFtTable_r, (py_data_pack_fn)pack_py_dfs_FlushFtTable_args_in, (py_data_unpack_fn)unpack_py_dfs_FlushFtTable_args_out, 18, &ndr_table_netdfs },
	{ "EnumEx", "S.EnumEx(dfs_name, level, bufsize, info, total) -> (info, total)", (py_dcerpc_call_fn)dcerpc_dfs_EnumEx_r, (py_data_pack_fn)pack_py_dfs_EnumEx_args_in, (py_data_unpack_fn)unpack_py_dfs_EnumEx_args_out, 21, &ndr_table_netdfs },
	{ NULL }
};

static PyObject *interface_netdfs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_netdfs);
}

#define PY_DOC_NETDFS "Settings for Microsoft Distributed File System"
static PyTypeObject netdfs_InterfaceType = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "dfs.netdfs",
	.tp_basicsize = sizeof(dcerpc_InterfaceObject),
	.tp_doc = "netdfs(binding, lp_ctx=None, credentials=None) -> connection\n"
"\n"
"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
"credentials should be a credentials.Credentials object.\n\n"PY_DOC_NETDFS,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = interface_netdfs_new,
};

static PyMethodDef dfs_methods[] = {
	{ NULL, NULL, 0, NULL }
};

void initdfs(void)
{
	PyObject *m;
	PyObject *dep_samba_dcerpc_misc;
	PyObject *dep_samba_dcerpc_base;
	PyObject *dep_talloc;

	dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
	if (dep_samba_dcerpc_misc == NULL)
		return;

	dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
	if (dep_samba_dcerpc_base == NULL)
		return;

	dep_talloc = PyImport_ImportModule("talloc");
	if (dep_talloc == NULL)
		return;

	Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
	if (Object_Type == NULL)
		return;

	ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
	if (ClientConnection_Type == NULL)
		return;

	GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
	if (GUID_Type == NULL)
		return;

	dfs_Info0_Type.tp_base = Object_Type;

	dfs_Info1_Type.tp_base = Object_Type;

	dfs_Info2_Type.tp_base = Object_Type;

	dfs_StorageInfo_Type.tp_base = Object_Type;

	dfs_Info3_Type.tp_base = Object_Type;

	dfs_Info4_Type.tp_base = Object_Type;

	dfs_Info5_Type.tp_base = Object_Type;

	dfs_Target_Priority_Type.tp_base = Object_Type;

	dfs_StorageInfo2_Type.tp_base = Object_Type;

	dfs_Info6_Type.tp_base = Object_Type;

	dfs_Info7_Type.tp_base = Object_Type;

	dfs_Info100_Type.tp_base = Object_Type;

	dfs_Info101_Type.tp_base = Object_Type;

	dfs_Info102_Type.tp_base = Object_Type;

	dfs_Info103_Type.tp_base = Object_Type;

	dfs_Info104_Type.tp_base = Object_Type;

	dfs_Info105_Type.tp_base = Object_Type;

	dfs_Info106_Type.tp_base = Object_Type;

	dfs_Info200_Type.tp_base = Object_Type;

	dfs_Info300_Type.tp_base = Object_Type;

	dfs_EnumArray1_Type.tp_base = Object_Type;

	dfs_EnumArray2_Type.tp_base = Object_Type;

	dfs_EnumArray3_Type.tp_base = Object_Type;

	dfs_EnumArray4_Type.tp_base = Object_Type;

	dfs_EnumArray5_Type.tp_base = Object_Type;

	dfs_EnumArray6_Type.tp_base = Object_Type;

	dfs_EnumArray200_Type.tp_base = Object_Type;

	dfs_EnumArray300_Type.tp_base = Object_Type;

	dfs_EnumStruct_Type.tp_base = Object_Type;

	dfs_UnknownStruct_Type.tp_base = Object_Type;

	netdfs_InterfaceType.tp_base = ClientConnection_Type;

	if (PyType_Ready(&dfs_Info0_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info1_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info2_Type) < 0)
		return;
	if (PyType_Ready(&dfs_StorageInfo_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info3_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info4_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info5_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Target_Priority_Type) < 0)
		return;
	if (PyType_Ready(&dfs_StorageInfo2_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info6_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info7_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info100_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info101_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info102_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info103_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info104_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info105_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info106_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info200_Type) < 0)
		return;
	if (PyType_Ready(&dfs_Info300_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray1_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray2_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray3_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray4_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray5_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray6_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray200_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumArray300_Type) < 0)
		return;
	if (PyType_Ready(&dfs_EnumStruct_Type) < 0)
		return;
	if (PyType_Ready(&dfs_UnknownStruct_Type) < 0)
		return;
	if (PyType_Ready(&netdfs_InterfaceType) < 0)
		return;
	if (!PyInterface_AddNdrRpcMethods(&netdfs_InterfaceType, py_ndr_netdfs_methods))
		return;

#ifdef PY_INFO0_PATCH
	PY_INFO0_PATCH(&dfs_Info0_Type);
#endif
#ifdef PY_INFO1_PATCH
	PY_INFO1_PATCH(&dfs_Info1_Type);
#endif
#ifdef PY_INFO2_PATCH
	PY_INFO2_PATCH(&dfs_Info2_Type);
#endif
#ifdef PY_STORAGEINFO_PATCH
	PY_STORAGEINFO_PATCH(&dfs_StorageInfo_Type);
#endif
#ifdef PY_INFO3_PATCH
	PY_INFO3_PATCH(&dfs_Info3_Type);
#endif
#ifdef PY_INFO4_PATCH
	PY_INFO4_PATCH(&dfs_Info4_Type);
#endif
#ifdef PY_INFO5_PATCH
	PY_INFO5_PATCH(&dfs_Info5_Type);
#endif
#ifdef PY_TARGET_PRIORITY_PATCH
	PY_TARGET_PRIORITY_PATCH(&dfs_Target_Priority_Type);
#endif
#ifdef PY_STORAGEINFO2_PATCH
	PY_STORAGEINFO2_PATCH(&dfs_StorageInfo2_Type);
#endif
#ifdef PY_INFO6_PATCH
	PY_INFO6_PATCH(&dfs_Info6_Type);
#endif
#ifdef PY_INFO7_PATCH
	PY_INFO7_PATCH(&dfs_Info7_Type);
#endif
#ifdef PY_INFO100_PATCH
	PY_INFO100_PATCH(&dfs_Info100_Type);
#endif
#ifdef PY_INFO101_PATCH
	PY_INFO101_PATCH(&dfs_Info101_Type);
#endif
#ifdef PY_INFO102_PATCH
	PY_INFO102_PATCH(&dfs_Info102_Type);
#endif
#ifdef PY_INFO103_PATCH
	PY_INFO103_PATCH(&dfs_Info103_Type);
#endif
#ifdef PY_INFO104_PATCH
	PY_INFO104_PATCH(&dfs_Info104_Type);
#endif
#ifdef PY_INFO105_PATCH
	PY_INFO105_PATCH(&dfs_Info105_Type);
#endif
#ifdef PY_INFO106_PATCH
	PY_INFO106_PATCH(&dfs_Info106_Type);
#endif
#ifdef PY_INFO200_PATCH
	PY_INFO200_PATCH(&dfs_Info200_Type);
#endif
#ifdef PY_INFO300_PATCH
	PY_INFO300_PATCH(&dfs_Info300_Type);
#endif
#ifdef PY_ENUMARRAY1_PATCH
	PY_ENUMARRAY1_PATCH(&dfs_EnumArray1_Type);
#endif
#ifdef PY_ENUMARRAY2_PATCH
	PY_ENUMARRAY2_PATCH(&dfs_EnumArray2_Type);
#endif
#ifdef PY_ENUMARRAY3_PATCH
	PY_ENUMARRAY3_PATCH(&dfs_EnumArray3_Type);
#endif
#ifdef PY_ENUMARRAY4_PATCH
	PY_ENUMARRAY4_PATCH(&dfs_EnumArray4_Type);
#endif
#ifdef PY_ENUMARRAY5_PATCH
	PY_ENUMARRAY5_PATCH(&dfs_EnumArray5_Type);
#endif
#ifdef PY_ENUMARRAY6_PATCH
	PY_ENUMARRAY6_PATCH(&dfs_EnumArray6_Type);
#endif
#ifdef PY_ENUMARRAY200_PATCH
	PY_ENUMARRAY200_PATCH(&dfs_EnumArray200_Type);
#endif
#ifdef PY_ENUMARRAY300_PATCH
	PY_ENUMARRAY300_PATCH(&dfs_EnumArray300_Type);
#endif
#ifdef PY_ENUMSTRUCT_PATCH
	PY_ENUMSTRUCT_PATCH(&dfs_EnumStruct_Type);
#endif
#ifdef PY_UNKNOWNSTRUCT_PATCH
	PY_UNKNOWNSTRUCT_PATCH(&dfs_UnknownStruct_Type);
#endif
#ifdef PY_NETDFS_PATCH
	PY_NETDFS_PATCH(&netdfs_InterfaceType);
#endif

	m = Py_InitModule3("dfs", dfs_methods, "dfs DCE/RPC");
	if (m == NULL)
		return;

	PyModule_AddObject(m, "DFS_INVALID_PRIORITY_CLASS", PyInt_FromLong(DFS_INVALID_PRIORITY_CLASS));
	PyModule_AddObject(m, "DFS_VOLUME_STATE_OFFLINE", PyInt_FromLong(DFS_VOLUME_STATE_OFFLINE));
	PyModule_AddObject(m, "DFS_VOLUME_FLAVOR_AD_BLOB", PyInt_FromLong(DFS_VOLUME_FLAVOR_AD_BLOB));
	PyModule_AddObject(m, "DFS_STORAGE_STATE_OFFLINE", PyInt_FromLong(DFS_STORAGE_STATE_OFFLINE));
	PyModule_AddObject(m, "DFS_GLOBAL_LOW_PRIORITY_CLASS", PyInt_FromLong(DFS_GLOBAL_LOW_PRIORITY_CLASS));
	PyModule_AddObject(m, "DFS_VOLUME_STATE_INCONSISTENT", PyInt_FromLong(DFS_VOLUME_STATE_INCONSISTENT));
	PyModule_AddObject(m, "DFS_PROPERTY_FLAG_TARGET_FAILBACK", PyInt_FromLong(DFS_PROPERTY_FLAG_TARGET_FAILBACK));
	PyModule_AddObject(m, "DFS_VOLUME_STATE_STANDALONE", PyInt_FromLong(DFS_VOLUME_STATE_STANDALONE));
	PyModule_AddObject(m, "DFS_MANAGER_VERSION_W2K", PyInt_FromLong(DFS_MANAGER_VERSION_W2K));
	PyModule_AddObject(m, "DFS_SITE_COST_NORMAL_PRIORITY_CLASS", PyInt_FromLong(DFS_SITE_COST_NORMAL_PRIORITY_CLASS));
	PyModule_AddObject(m, "DFS_PROPERTY_FLAG_INSITE_REFERRALS", PyInt_FromLong(DFS_PROPERTY_FLAG_INSITE_REFERRALS));
	PyModule_AddObject(m, "DFS_PROPERTY_FLAG_SITE_COSTING", PyInt_FromLong(DFS_PROPERTY_FLAG_SITE_COSTING));
	PyModule_AddObject(m, "DFS_STORAGE_STATE_ONLINE", PyInt_FromLong(DFS_STORAGE_STATE_ONLINE));
	PyModule_AddObject(m, "DFS_MANAGER_VERSION_W2K8", PyInt_FromLong(DFS_MANAGER_VERSION_W2K8));
	PyModule_AddObject(m, "DFS_GLOBAL_HIGH_PRIORITY_CLASS", PyInt_FromLong(DFS_GLOBAL_HIGH_PRIORITY_CLASS));
	PyModule_AddObject(m, "DFS_STORAGE_STATES", PyInt_FromLong(0xf));
	PyModule_AddObject(m, "DFS_PROPERTY_FLAG_CLUSTER_ENABLED", PyInt_FromLong(DFS_PROPERTY_FLAG_CLUSTER_ENABLED));
	PyModule_AddObject(m, "DFS_SITE_COST_LOW_PRIORITY_CLASS", PyInt_FromLong(DFS_SITE_COST_LOW_PRIORITY_CLASS));
	PyModule_AddObject(m, "DFS_PROPERTY_FLAG_ROOT_SCALABILITY", PyInt_FromLong(DFS_PROPERTY_FLAG_ROOT_SCALABILITY));
	PyModule_AddObject(m, "DFS_SITE_COST_HIGH_PRIORITY_CLASS", PyInt_FromLong(DFS_SITE_COST_HIGH_PRIORITY_CLASS));
	PyModule_AddObject(m, "DFS_VOLUME_STATE_ONLINE", PyInt_FromLong(DFS_VOLUME_STATE_ONLINE));
	PyModule_AddObject(m, "DFS_STORAGE_STATE_ACTIVE", PyInt_FromLong(DFS_STORAGE_STATE_ACTIVE));
	PyModule_AddObject(m, "DFS_MANAGER_VERSION_NT4", PyInt_FromLong(DFS_MANAGER_VERSION_NT4));
	PyModule_AddObject(m, "DFS_MANAGER_VERSION_W2K3", PyInt_FromLong(DFS_MANAGER_VERSION_W2K3));
	PyModule_AddObject(m, "DFS_VOLUME_FLAVOR_STANDALONE", PyInt_FromLong(DFS_VOLUME_FLAVOR_STANDALONE));
	PyModule_AddObject(m, "DFS_VOLUME_STATE_AD_BLOB", PyInt_FromLong(DFS_VOLUME_STATE_AD_BLOB));
	PyModule_AddObject(m, "DFS_VOLUME_STATE_OK", PyInt_FromLong(DFS_VOLUME_STATE_OK));
	Py_INCREF((PyObject *)(void *)&dfs_Info0_Type);
	PyModule_AddObject(m, "Info0", (PyObject *)(void *)&dfs_Info0_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info1_Type);
	PyModule_AddObject(m, "Info1", (PyObject *)(void *)&dfs_Info1_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info2_Type);
	PyModule_AddObject(m, "Info2", (PyObject *)(void *)&dfs_Info2_Type);
	Py_INCREF((PyObject *)(void *)&dfs_StorageInfo_Type);
	PyModule_AddObject(m, "StorageInfo", (PyObject *)(void *)&dfs_StorageInfo_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info3_Type);
	PyModule_AddObject(m, "Info3", (PyObject *)(void *)&dfs_Info3_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info4_Type);
	PyModule_AddObject(m, "Info4", (PyObject *)(void *)&dfs_Info4_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info5_Type);
	PyModule_AddObject(m, "Info5", (PyObject *)(void *)&dfs_Info5_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Target_Priority_Type);
	PyModule_AddObject(m, "Target_Priority", (PyObject *)(void *)&dfs_Target_Priority_Type);
	Py_INCREF((PyObject *)(void *)&dfs_StorageInfo2_Type);
	PyModule_AddObject(m, "StorageInfo2", (PyObject *)(void *)&dfs_StorageInfo2_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info6_Type);
	PyModule_AddObject(m, "Info6", (PyObject *)(void *)&dfs_Info6_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info7_Type);
	PyModule_AddObject(m, "Info7", (PyObject *)(void *)&dfs_Info7_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info100_Type);
	PyModule_AddObject(m, "Info100", (PyObject *)(void *)&dfs_Info100_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info101_Type);
	PyModule_AddObject(m, "Info101", (PyObject *)(void *)&dfs_Info101_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info102_Type);
	PyModule_AddObject(m, "Info102", (PyObject *)(void *)&dfs_Info102_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info103_Type);
	PyModule_AddObject(m, "Info103", (PyObject *)(void *)&dfs_Info103_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info104_Type);
	PyModule_AddObject(m, "Info104", (PyObject *)(void *)&dfs_Info104_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info105_Type);
	PyModule_AddObject(m, "Info105", (PyObject *)(void *)&dfs_Info105_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info106_Type);
	PyModule_AddObject(m, "Info106", (PyObject *)(void *)&dfs_Info106_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info200_Type);
	PyModule_AddObject(m, "Info200", (PyObject *)(void *)&dfs_Info200_Type);
	Py_INCREF((PyObject *)(void *)&dfs_Info300_Type);
	PyModule_AddObject(m, "Info300", (PyObject *)(void *)&dfs_Info300_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray1_Type);
	PyModule_AddObject(m, "EnumArray1", (PyObject *)(void *)&dfs_EnumArray1_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray2_Type);
	PyModule_AddObject(m, "EnumArray2", (PyObject *)(void *)&dfs_EnumArray2_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray3_Type);
	PyModule_AddObject(m, "EnumArray3", (PyObject *)(void *)&dfs_EnumArray3_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray4_Type);
	PyModule_AddObject(m, "EnumArray4", (PyObject *)(void *)&dfs_EnumArray4_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray5_Type);
	PyModule_AddObject(m, "EnumArray5", (PyObject *)(void *)&dfs_EnumArray5_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray6_Type);
	PyModule_AddObject(m, "EnumArray6", (PyObject *)(void *)&dfs_EnumArray6_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray200_Type);
	PyModule_AddObject(m, "EnumArray200", (PyObject *)(void *)&dfs_EnumArray200_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumArray300_Type);
	PyModule_AddObject(m, "EnumArray300", (PyObject *)(void *)&dfs_EnumArray300_Type);
	Py_INCREF((PyObject *)(void *)&dfs_EnumStruct_Type);
	PyModule_AddObject(m, "EnumStruct", (PyObject *)(void *)&dfs_EnumStruct_Type);
	Py_INCREF((PyObject *)(void *)&dfs_UnknownStruct_Type);
	PyModule_AddObject(m, "UnknownStruct", (PyObject *)(void *)&dfs_UnknownStruct_Type);
	Py_INCREF((PyObject *)(void *)&netdfs_InterfaceType);
	PyModule_AddObject(m, "netdfs", (PyObject *)(void *)&netdfs_InterfaceType);
#ifdef PY_MOD_DFS_PATCH
	PY_MOD_DFS_PATCH(m);
#endif

}