
/* 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 "autoconf/librpc/gen_ndr/ndr_srvsvc.h"
#include "autoconf/librpc/gen_ndr/ndr_srvsvc_c.h"

#include "librpc/gen_ndr/misc.h"
#include "librpc/gen_ndr/security.h"
#include "librpc/gen_ndr/svcctl.h"
staticforward PyTypeObject srvsvc_NetCharDevInfo0_Type;
staticforward PyTypeObject srvsvc_NetCharDevCtr0_Type;
staticforward PyTypeObject srvsvc_NetCharDevInfo1_Type;
staticforward PyTypeObject srvsvc_NetCharDevCtr1_Type;
staticforward PyTypeObject srvsvc_NetCharDevInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetCharDevQInfo0_Type;
staticforward PyTypeObject srvsvc_NetCharDevQCtr0_Type;
staticforward PyTypeObject srvsvc_NetCharDevQInfo1_Type;
staticforward PyTypeObject srvsvc_NetCharDevQCtr1_Type;
staticforward PyTypeObject srvsvc_NetCharDevQInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetConnInfo0_Type;
staticforward PyTypeObject srvsvc_NetConnCtr0_Type;
staticforward PyTypeObject srvsvc_NetConnInfo1_Type;
staticforward PyTypeObject srvsvc_NetConnCtr1_Type;
staticforward PyTypeObject srvsvc_NetConnInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetFileInfo2_Type;
staticforward PyTypeObject srvsvc_NetFileCtr2_Type;
staticforward PyTypeObject srvsvc_NetFileInfo3_Type;
staticforward PyTypeObject srvsvc_NetFileCtr3_Type;
staticforward PyTypeObject srvsvc_NetFileInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetSessInfo0_Type;
staticforward PyTypeObject srvsvc_NetSessCtr0_Type;
staticforward PyTypeObject srvsvc_NetSessInfo1_Type;
staticforward PyTypeObject srvsvc_NetSessCtr1_Type;
staticforward PyTypeObject srvsvc_NetSessInfo2_Type;
staticforward PyTypeObject srvsvc_NetSessCtr2_Type;
staticforward PyTypeObject srvsvc_NetSessInfo10_Type;
staticforward PyTypeObject srvsvc_NetSessCtr10_Type;
staticforward PyTypeObject srvsvc_NetSessInfo502_Type;
staticforward PyTypeObject srvsvc_NetSessCtr502_Type;
staticforward PyTypeObject srvsvc_NetSessInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetShareInfo0_Type;
staticforward PyTypeObject srvsvc_NetShareCtr0_Type;
staticforward PyTypeObject srvsvc_NetShareInfo1_Type;
staticforward PyTypeObject srvsvc_NetShareCtr1_Type;
staticforward PyTypeObject srvsvc_NetShareInfo2_Type;
staticforward PyTypeObject srvsvc_NetShareCtr2_Type;
staticforward PyTypeObject srvsvc_NetShareInfo501_Type;
staticforward PyTypeObject srvsvc_NetShareCtr501_Type;
staticforward PyTypeObject srvsvc_NetShareInfo502_Type;
staticforward PyTypeObject srvsvc_NetShareCtr502_Type;
staticforward PyTypeObject srvsvc_NetShareInfo1004_Type;
staticforward PyTypeObject srvsvc_NetShareCtr1004_Type;
staticforward PyTypeObject srvsvc_NetShareInfo1005_Type;
staticforward PyTypeObject srvsvc_NetShareCtr1005_Type;
staticforward PyTypeObject srvsvc_NetShareInfo1006_Type;
staticforward PyTypeObject srvsvc_NetShareCtr1006_Type;
staticforward PyTypeObject srvsvc_NetShareInfo1007_Type;
staticforward PyTypeObject srvsvc_NetShareCtr1007_Type;
staticforward PyTypeObject srvsvc_NetShareCtr1501_Type;
staticforward PyTypeObject srvsvc_NetShareInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo100_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo101_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo102_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo402_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo403_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo502_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo503_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo599_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1005_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1010_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1016_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1017_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1018_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1107_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1501_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1502_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1503_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1506_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1509_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1510_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1511_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1512_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1513_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1514_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1515_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1516_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1518_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1520_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1521_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1522_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1523_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1524_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1525_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1528_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1529_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1530_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1533_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1534_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1535_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1536_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1537_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1538_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1539_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1540_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1541_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1542_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1543_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1544_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1545_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1546_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1547_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1548_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1549_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1550_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1552_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1553_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1554_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1555_Type;
staticforward PyTypeObject srvsvc_NetSrvInfo1556_Type;
staticforward PyTypeObject srvsvc_NetDiskInfo0_Type;
staticforward PyTypeObject srvsvc_NetDiskInfo_Type;
staticforward PyTypeObject srvsvc_Statistics_Type;
staticforward PyTypeObject srvsvc_NetTransportInfo0_Type;
staticforward PyTypeObject srvsvc_NetTransportCtr0_Type;
staticforward PyTypeObject srvsvc_NetTransportInfo1_Type;
staticforward PyTypeObject srvsvc_NetTransportCtr1_Type;
staticforward PyTypeObject srvsvc_NetTransportInfo2_Type;
staticforward PyTypeObject srvsvc_NetTransportCtr2_Type;
staticforward PyTypeObject srvsvc_NetTransportInfo3_Type;
staticforward PyTypeObject srvsvc_NetTransportCtr3_Type;
staticforward PyTypeObject srvsvc_NetTransportInfoCtr_Type;
staticforward PyTypeObject srvsvc_NetRemoteTODInfo_Type;
staticforward PyTypeObject srvsvc_InterfaceType;

void initsrvsvc(void);static PyTypeObject *sec_desc_buf_Type;
static PyTypeObject *policy_handle_Type;
static PyTypeObject *Object_Type;
static PyTypeObject *ClientConnection_Type;

static PyObject *py_srvsvc_NetCharDevInfo0_get_device(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfo0 *object = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_device;
	if (object->device == NULL) {
		py_device = Py_None;
		Py_INCREF(py_device);
	} else {
		if (object->device == NULL) {
			py_device = Py_None;
			Py_INCREF(py_device);
		} else {
			py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
		}
	}
	return py_device;
}

static int py_srvsvc_NetCharDevInfo0_set_device(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevInfo0 *object = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->device = NULL;
	} else {
		object->device = NULL;
		if (PyUnicode_Check(value)) {
			object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->device = 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_srvsvc_NetCharDevInfo0_getsetters[] = {
	{ discard_const_p(char, "device"), py_srvsvc_NetCharDevInfo0_get_device, py_srvsvc_NetCharDevInfo0_set_device },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevInfo0, type);
}


static PyTypeObject srvsvc_NetCharDevInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevInfo0",
	.tp_getset = py_srvsvc_NetCharDevInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevInfo0_new,
};


static PyObject *py_srvsvc_NetCharDevCtr0_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetCharDevCtr0_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetCharDevCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetCharDevInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetCharDevCtr0_get_count, py_srvsvc_NetCharDevCtr0_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetCharDevCtr0_get_array, py_srvsvc_NetCharDevCtr0_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevCtr0, type);
}


static PyTypeObject srvsvc_NetCharDevCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevCtr0",
	.tp_getset = py_srvsvc_NetCharDevCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevCtr0_new,
};


static PyObject *py_srvsvc_NetCharDevInfo1_get_device(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_device;
	if (object->device == NULL) {
		py_device = Py_None;
		Py_INCREF(py_device);
	} else {
		if (object->device == NULL) {
			py_device = Py_None;
			Py_INCREF(py_device);
		} else {
			py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
		}
	}
	return py_device;
}

static int py_srvsvc_NetCharDevInfo1_set_device(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->device = NULL;
	} else {
		object->device = NULL;
		if (PyUnicode_Check(value)) {
			object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->device = 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_srvsvc_NetCharDevInfo1_get_status(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_status;
	py_status = PyInt_FromLong(object->status);
	return py_status;
}

static int py_srvsvc_NetCharDevInfo1_set_status(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->status = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetCharDevInfo1_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetCharDevInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetCharDevInfo1_get_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_time;
	py_time = PyInt_FromLong(object->time);
	return py_time;
}

static int py_srvsvc_NetCharDevInfo1_set_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->time = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevInfo1_getsetters[] = {
	{ discard_const_p(char, "device"), py_srvsvc_NetCharDevInfo1_get_device, py_srvsvc_NetCharDevInfo1_set_device },
	{ discard_const_p(char, "status"), py_srvsvc_NetCharDevInfo1_get_status, py_srvsvc_NetCharDevInfo1_set_status },
	{ discard_const_p(char, "user"), py_srvsvc_NetCharDevInfo1_get_user, py_srvsvc_NetCharDevInfo1_set_user },
	{ discard_const_p(char, "time"), py_srvsvc_NetCharDevInfo1_get_time, py_srvsvc_NetCharDevInfo1_set_time },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevInfo1, type);
}


static PyTypeObject srvsvc_NetCharDevInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevInfo1",
	.tp_getset = py_srvsvc_NetCharDevInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevInfo1_new,
};


static PyObject *py_srvsvc_NetCharDevCtr1_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetCharDevCtr1_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetCharDevCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetCharDevInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetCharDevCtr1_get_count, py_srvsvc_NetCharDevCtr1_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetCharDevCtr1_get_array, py_srvsvc_NetCharDevCtr1_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevCtr1, type);
}


static PyTypeObject srvsvc_NetCharDevCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevCtr1",
	.tp_getset = py_srvsvc_NetCharDevCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevCtr1_new,
};

PyObject *py_import_srvsvc_NetCharDevInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevInfo *in)
{
	PyObject *ret;

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

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

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetCharDevInfo *py_export_srvsvc_NetCharDevInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetCharDevInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevInfo);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->info0 = NULL;
			} else {
				ret->info0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevInfo0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info0 = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevInfo1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1 = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}

PyObject *py_import_srvsvc_NetCharDevCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->ctr0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetCharDevCtr0_Type, in->ctr0, in->ctr0);
			}
			return ret;

		case 1:
			if (in->ctr1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetCharDevCtr1_Type, in->ctr1, in->ctr1);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetCharDevCtr *py_export_srvsvc_NetCharDevCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetCharDevCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevCtr0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr0 = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevCtr1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1 = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetCharDevInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetCharDevInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetCharDevCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetCharDevInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetCharDevCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetCharDevCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetCharDevInfoCtr_get_level, py_srvsvc_NetCharDevInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetCharDevInfoCtr_get_ctr, py_srvsvc_NetCharDevInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevInfoCtr, type);
}


static PyTypeObject srvsvc_NetCharDevInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevInfoCtr",
	.tp_getset = py_srvsvc_NetCharDevInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevInfoCtr_new,
};


static PyObject *py_srvsvc_NetCharDevQInfo0_get_device(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfo0 *object = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_device;
	if (object->device == NULL) {
		py_device = Py_None;
		Py_INCREF(py_device);
	} else {
		if (object->device == NULL) {
			py_device = Py_None;
			Py_INCREF(py_device);
		} else {
			py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
		}
	}
	return py_device;
}

static int py_srvsvc_NetCharDevQInfo0_set_device(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfo0 *object = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->device = NULL;
	} else {
		object->device = NULL;
		if (PyUnicode_Check(value)) {
			object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->device = 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_srvsvc_NetCharDevQInfo0_getsetters[] = {
	{ discard_const_p(char, "device"), py_srvsvc_NetCharDevQInfo0_get_device, py_srvsvc_NetCharDevQInfo0_set_device },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevQInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevQInfo0, type);
}


static PyTypeObject srvsvc_NetCharDevQInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevQInfo0",
	.tp_getset = py_srvsvc_NetCharDevQInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevQInfo0_new,
};


static PyObject *py_srvsvc_NetCharDevQCtr0_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetCharDevQCtr0_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetCharDevQCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevQCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetCharDevQCtr0_get_count, py_srvsvc_NetCharDevQCtr0_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetCharDevQCtr0_get_array, py_srvsvc_NetCharDevQCtr0_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevQCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevQCtr0, type);
}


static PyTypeObject srvsvc_NetCharDevQCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevQCtr0",
	.tp_getset = py_srvsvc_NetCharDevQCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevQCtr0_new,
};


static PyObject *py_srvsvc_NetCharDevQInfo1_get_device(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_device;
	if (object->device == NULL) {
		py_device = Py_None;
		Py_INCREF(py_device);
	} else {
		if (object->device == NULL) {
			py_device = Py_None;
			Py_INCREF(py_device);
		} else {
			py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
		}
	}
	return py_device;
}

static int py_srvsvc_NetCharDevQInfo1_set_device(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->device = NULL;
	} else {
		object->device = NULL;
		if (PyUnicode_Check(value)) {
			object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->device = 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_srvsvc_NetCharDevQInfo1_get_priority(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_priority;
	py_priority = PyInt_FromLong(object->priority);
	return py_priority;
}

static int py_srvsvc_NetCharDevQInfo1_set_priority(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->priority = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetCharDevQInfo1_get_devices(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_devices;
	if (object->devices == NULL) {
		py_devices = Py_None;
		Py_INCREF(py_devices);
	} else {
		if (object->devices == NULL) {
			py_devices = Py_None;
			Py_INCREF(py_devices);
		} else {
			py_devices = PyUnicode_Decode(object->devices, strlen(object->devices), "utf-8", "ignore");
		}
	}
	return py_devices;
}

static int py_srvsvc_NetCharDevQInfo1_set_devices(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->devices = NULL;
	} else {
		object->devices = NULL;
		if (PyUnicode_Check(value)) {
			object->devices = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->devices = 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_srvsvc_NetCharDevQInfo1_get_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_users;
	py_users = PyInt_FromLong(object->users);
	return py_users;
}

static int py_srvsvc_NetCharDevQInfo1_set_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetCharDevQInfo1_get_num_ahead(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_num_ahead;
	py_num_ahead = PyInt_FromLong(object->num_ahead);
	return py_num_ahead;
}

static int py_srvsvc_NetCharDevQInfo1_set_num_ahead(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_ahead = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevQInfo1_getsetters[] = {
	{ discard_const_p(char, "device"), py_srvsvc_NetCharDevQInfo1_get_device, py_srvsvc_NetCharDevQInfo1_set_device },
	{ discard_const_p(char, "priority"), py_srvsvc_NetCharDevQInfo1_get_priority, py_srvsvc_NetCharDevQInfo1_set_priority },
	{ discard_const_p(char, "devices"), py_srvsvc_NetCharDevQInfo1_get_devices, py_srvsvc_NetCharDevQInfo1_set_devices },
	{ discard_const_p(char, "users"), py_srvsvc_NetCharDevQInfo1_get_users, py_srvsvc_NetCharDevQInfo1_set_users },
	{ discard_const_p(char, "num_ahead"), py_srvsvc_NetCharDevQInfo1_get_num_ahead, py_srvsvc_NetCharDevQInfo1_set_num_ahead },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevQInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevQInfo1, type);
}


static PyTypeObject srvsvc_NetCharDevQInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevQInfo1",
	.tp_getset = py_srvsvc_NetCharDevQInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevQInfo1_new,
};


static PyObject *py_srvsvc_NetCharDevQCtr1_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetCharDevQCtr1_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetCharDevQCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevQCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetCharDevQCtr1_get_count, py_srvsvc_NetCharDevQCtr1_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetCharDevQCtr1_get_array, py_srvsvc_NetCharDevQCtr1_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevQCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevQCtr1, type);
}


static PyTypeObject srvsvc_NetCharDevQCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevQCtr1",
	.tp_getset = py_srvsvc_NetCharDevQCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevQCtr1_new,
};

PyObject *py_import_srvsvc_NetCharDevQInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevQInfo *in)
{
	PyObject *ret;

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

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

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetCharDevQInfo *py_export_srvsvc_NetCharDevQInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetCharDevQInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevQInfo);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->info0 = NULL;
			} else {
				ret->info0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info0 = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1 = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}

PyObject *py_import_srvsvc_NetCharDevQCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevQCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->ctr0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetCharDevQCtr0_Type, in->ctr0, in->ctr0);
			}
			return ret;

		case 1:
			if (in->ctr1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetCharDevQCtr1_Type, in->ctr1, in->ctr1);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetCharDevQCtr *py_export_srvsvc_NetCharDevQCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetCharDevQCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevQCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevQCtr0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr0 = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetCharDevQCtr1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1 = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetCharDevQInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetCharDevQInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetCharDevQCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetCharDevQInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetCharDevQCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetCharDevQCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetCharDevQInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetCharDevQInfoCtr_get_level, py_srvsvc_NetCharDevQInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetCharDevQInfoCtr_get_ctr, py_srvsvc_NetCharDevQInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetCharDevQInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetCharDevQInfoCtr, type);
}


static PyTypeObject srvsvc_NetCharDevQInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetCharDevQInfoCtr",
	.tp_getset = py_srvsvc_NetCharDevQInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetCharDevQInfoCtr_new,
};


static PyObject *py_srvsvc_NetConnInfo0_get_conn_id(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo0 *object = (struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_conn_id;
	py_conn_id = PyInt_FromLong(object->conn_id);
	return py_conn_id;
}

static int py_srvsvc_NetConnInfo0_set_conn_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo0 *object = (struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->conn_id = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetConnInfo0_getsetters[] = {
	{ discard_const_p(char, "conn_id"), py_srvsvc_NetConnInfo0_get_conn_id, py_srvsvc_NetConnInfo0_set_conn_id },
	{ NULL }
};

static PyObject *py_srvsvc_NetConnInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetConnInfo0, type);
}


static PyTypeObject srvsvc_NetConnInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetConnInfo0",
	.tp_getset = py_srvsvc_NetConnInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetConnInfo0_new,
};


static PyObject *py_srvsvc_NetConnCtr0_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetConnCtr0_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetConnInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetConnCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetConnInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetConnCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetConnCtr0_get_count, py_srvsvc_NetConnCtr0_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetConnCtr0_get_array, py_srvsvc_NetConnCtr0_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetConnCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetConnCtr0, type);
}


static PyTypeObject srvsvc_NetConnCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetConnCtr0",
	.tp_getset = py_srvsvc_NetConnCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetConnCtr0_new,
};


static PyObject *py_srvsvc_NetConnInfo1_get_conn_id(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_conn_id;
	py_conn_id = PyInt_FromLong(object->conn_id);
	return py_conn_id;
}

static int py_srvsvc_NetConnInfo1_set_conn_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->conn_id = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetConnInfo1_get_conn_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_conn_type;
	py_conn_type = PyInt_FromLong(object->conn_type);
	return py_conn_type;
}

static int py_srvsvc_NetConnInfo1_set_conn_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->conn_type = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetConnInfo1_get_num_open(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_num_open;
	py_num_open = PyInt_FromLong(object->num_open);
	return py_num_open;
}

static int py_srvsvc_NetConnInfo1_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_open = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetConnInfo1_get_num_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_num_users;
	py_num_users = PyInt_FromLong(object->num_users);
	return py_num_users;
}

static int py_srvsvc_NetConnInfo1_set_num_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetConnInfo1_get_conn_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_conn_time;
	py_conn_time = PyInt_FromLong(object->conn_time);
	return py_conn_time;
}

static int py_srvsvc_NetConnInfo1_set_conn_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->conn_time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetConnInfo1_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetConnInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetConnInfo1_get_share(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_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_srvsvc_NetConnInfo1_set_share(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_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_srvsvc_NetConnInfo1_getsetters[] = {
	{ discard_const_p(char, "conn_id"), py_srvsvc_NetConnInfo1_get_conn_id, py_srvsvc_NetConnInfo1_set_conn_id },
	{ discard_const_p(char, "conn_type"), py_srvsvc_NetConnInfo1_get_conn_type, py_srvsvc_NetConnInfo1_set_conn_type },
	{ discard_const_p(char, "num_open"), py_srvsvc_NetConnInfo1_get_num_open, py_srvsvc_NetConnInfo1_set_num_open },
	{ discard_const_p(char, "num_users"), py_srvsvc_NetConnInfo1_get_num_users, py_srvsvc_NetConnInfo1_set_num_users },
	{ discard_const_p(char, "conn_time"), py_srvsvc_NetConnInfo1_get_conn_time, py_srvsvc_NetConnInfo1_set_conn_time },
	{ discard_const_p(char, "user"), py_srvsvc_NetConnInfo1_get_user, py_srvsvc_NetConnInfo1_set_user },
	{ discard_const_p(char, "share"), py_srvsvc_NetConnInfo1_get_share, py_srvsvc_NetConnInfo1_set_share },
	{ NULL }
};

static PyObject *py_srvsvc_NetConnInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetConnInfo1, type);
}


static PyTypeObject srvsvc_NetConnInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetConnInfo1",
	.tp_getset = py_srvsvc_NetConnInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetConnInfo1_new,
};


static PyObject *py_srvsvc_NetConnCtr1_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetConnCtr1_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetConnInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetConnCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetConnInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetConnCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetConnCtr1_get_count, py_srvsvc_NetConnCtr1_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetConnCtr1_get_array, py_srvsvc_NetConnCtr1_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetConnCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetConnCtr1, type);
}


static PyTypeObject srvsvc_NetConnCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetConnCtr1",
	.tp_getset = py_srvsvc_NetConnCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetConnCtr1_new,
};

PyObject *py_import_srvsvc_NetConnCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetConnCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->ctr0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetConnCtr0_Type, in->ctr0, in->ctr0);
			}
			return ret;

		case 1:
			if (in->ctr1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetConnCtr1_Type, in->ctr1, in->ctr1);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetConnCtr *py_export_srvsvc_NetConnCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetConnCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetConnCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetConnCtr0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr0 = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetConnCtr1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1 = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetConnInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetConnInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetConnCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetConnInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetConnCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetConnCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetConnInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetConnInfoCtr_get_level, py_srvsvc_NetConnInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetConnInfoCtr_get_ctr, py_srvsvc_NetConnInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetConnInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetConnInfoCtr, type);
}


static PyTypeObject srvsvc_NetConnInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetConnInfoCtr",
	.tp_getset = py_srvsvc_NetConnInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetConnInfoCtr_new,
};


static PyObject *py_srvsvc_NetFileInfo2_get_fid(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfo2 *object = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_fid;
	py_fid = PyInt_FromLong(object->fid);
	return py_fid;
}

static int py_srvsvc_NetFileInfo2_set_fid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfo2 *object = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->fid = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetFileInfo2_getsetters[] = {
	{ discard_const_p(char, "fid"), py_srvsvc_NetFileInfo2_get_fid, py_srvsvc_NetFileInfo2_set_fid },
	{ NULL }
};

static PyObject *py_srvsvc_NetFileInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetFileInfo2, type);
}


static PyTypeObject srvsvc_NetFileInfo2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetFileInfo2",
	.tp_getset = py_srvsvc_NetFileInfo2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetFileInfo2_new,
};


static PyObject *py_srvsvc_NetFileCtr2_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetFileCtr2_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetFileInfo2_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetFileCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetFileInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetFileCtr2_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetFileCtr2_get_count, py_srvsvc_NetFileCtr2_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetFileCtr2_get_array, py_srvsvc_NetFileCtr2_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetFileCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetFileCtr2, type);
}


static PyTypeObject srvsvc_NetFileCtr2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetFileCtr2",
	.tp_getset = py_srvsvc_NetFileCtr2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetFileCtr2_new,
};


static PyObject *py_srvsvc_NetFileInfo3_get_fid(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_fid;
	py_fid = PyInt_FromLong(object->fid);
	return py_fid;
}

static int py_srvsvc_NetFileInfo3_set_fid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->fid = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetFileInfo3_get_permissions(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_permissions;
	py_permissions = PyInt_FromLong(object->permissions);
	return py_permissions;
}

static int py_srvsvc_NetFileInfo3_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->permissions = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetFileInfo3_get_num_locks(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_num_locks;
	py_num_locks = PyInt_FromLong(object->num_locks);
	return py_num_locks;
}

static int py_srvsvc_NetFileInfo3_set_num_locks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_locks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetFileInfo3_get_path(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_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_srvsvc_NetFileInfo3_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_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_srvsvc_NetFileInfo3_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetFileInfo3_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetFileInfo3_getsetters[] = {
	{ discard_const_p(char, "fid"), py_srvsvc_NetFileInfo3_get_fid, py_srvsvc_NetFileInfo3_set_fid },
	{ discard_const_p(char, "permissions"), py_srvsvc_NetFileInfo3_get_permissions, py_srvsvc_NetFileInfo3_set_permissions },
	{ discard_const_p(char, "num_locks"), py_srvsvc_NetFileInfo3_get_num_locks, py_srvsvc_NetFileInfo3_set_num_locks },
	{ discard_const_p(char, "path"), py_srvsvc_NetFileInfo3_get_path, py_srvsvc_NetFileInfo3_set_path },
	{ discard_const_p(char, "user"), py_srvsvc_NetFileInfo3_get_user, py_srvsvc_NetFileInfo3_set_user },
	{ NULL }
};

static PyObject *py_srvsvc_NetFileInfo3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetFileInfo3, type);
}


static PyTypeObject srvsvc_NetFileInfo3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetFileInfo3",
	.tp_getset = py_srvsvc_NetFileInfo3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetFileInfo3_new,
};


static PyObject *py_srvsvc_NetFileCtr3_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetFileCtr3_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetFileInfo3_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetFileCtr3_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetFileInfo3_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetFileCtr3_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetFileCtr3_get_count, py_srvsvc_NetFileCtr3_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetFileCtr3_get_array, py_srvsvc_NetFileCtr3_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetFileCtr3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetFileCtr3, type);
}


static PyTypeObject srvsvc_NetFileCtr3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetFileCtr3",
	.tp_getset = py_srvsvc_NetFileCtr3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetFileCtr3_new,
};

PyObject *py_import_srvsvc_NetFileInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetFileInfo *in)
{
	PyObject *ret;

	switch (level) {
		case 2:
			if (in->info2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetFileInfo2_Type, in->info2, in->info2);
			}
			return ret;

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

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetFileInfo *py_export_srvsvc_NetFileInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetFileInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetFileInfo);
	switch (level) {
		case 2:
			if (in == Py_None) {
				ret->info2 = NULL;
			} else {
				ret->info2 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetFileInfo2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info2 = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(in);
			}
			break;

		case 3:
			if (in == Py_None) {
				ret->info3 = NULL;
			} else {
				ret->info3 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetFileInfo3_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info3 = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}

PyObject *py_import_srvsvc_NetFileCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetFileCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 2:
			if (in->ctr2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetFileCtr2_Type, in->ctr2, in->ctr2);
			}
			return ret;

		case 3:
			if (in->ctr3 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetFileCtr3_Type, in->ctr3, in->ctr3);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetFileCtr *py_export_srvsvc_NetFileCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetFileCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetFileCtr);
	switch (level) {
		case 2:
			if (in == Py_None) {
				ret->ctr2 = NULL;
			} else {
				ret->ctr2 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetFileCtr2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr2 = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(in);
			}
			break;

		case 3:
			if (in == Py_None) {
				ret->ctr3 = NULL;
			} else {
				ret->ctr3 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetFileCtr3_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr3 = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetFileInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetFileInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetFileCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetFileInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetFileCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetFileCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetFileInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetFileInfoCtr_get_level, py_srvsvc_NetFileInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetFileInfoCtr_get_ctr, py_srvsvc_NetFileInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetFileInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetFileInfoCtr, type);
}


static PyTypeObject srvsvc_NetFileInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetFileInfoCtr",
	.tp_getset = py_srvsvc_NetFileInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetFileInfoCtr_new,
};


static PyObject *py_srvsvc_NetSessInfo0_get_client(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo0 *object = (struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_client;
	if (object->client == NULL) {
		py_client = Py_None;
		Py_INCREF(py_client);
	} else {
		if (object->client == NULL) {
			py_client = Py_None;
			Py_INCREF(py_client);
		} else {
			py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
		}
	}
	return py_client;
}

static int py_srvsvc_NetSessInfo0_set_client(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo0 *object = (struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client = NULL;
	} else {
		object->client = NULL;
		if (PyUnicode_Check(value)) {
			object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client = 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_srvsvc_NetSessInfo0_getsetters[] = {
	{ discard_const_p(char, "client"), py_srvsvc_NetSessInfo0_get_client, py_srvsvc_NetSessInfo0_set_client },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessInfo0, type);
}


static PyTypeObject srvsvc_NetSessInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessInfo0",
	.tp_getset = py_srvsvc_NetSessInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessInfo0_new,
};


static PyObject *py_srvsvc_NetSessCtr0_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetSessCtr0_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetSessCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetSessInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetSessCtr0_get_count, py_srvsvc_NetSessCtr0_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetSessCtr0_get_array, py_srvsvc_NetSessCtr0_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessCtr0, type);
}


static PyTypeObject srvsvc_NetSessCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessCtr0",
	.tp_getset = py_srvsvc_NetSessCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessCtr0_new,
};


static PyObject *py_srvsvc_NetSessInfo1_get_client(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_client;
	if (object->client == NULL) {
		py_client = Py_None;
		Py_INCREF(py_client);
	} else {
		if (object->client == NULL) {
			py_client = Py_None;
			Py_INCREF(py_client);
		} else {
			py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
		}
	}
	return py_client;
}

static int py_srvsvc_NetSessInfo1_set_client(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client = NULL;
	} else {
		object->client = NULL;
		if (PyUnicode_Check(value)) {
			object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client = 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_srvsvc_NetSessInfo1_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetSessInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetSessInfo1_get_num_open(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_num_open;
	py_num_open = PyInt_FromLong(object->num_open);
	return py_num_open;
}

static int py_srvsvc_NetSessInfo1_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_open = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo1_get_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_time;
	py_time = PyInt_FromLong(object->time);
	return py_time;
}

static int py_srvsvc_NetSessInfo1_set_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo1_get_idle_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_idle_time;
	py_idle_time = PyInt_FromLong(object->idle_time);
	return py_idle_time;
}

static int py_srvsvc_NetSessInfo1_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->idle_time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo1_get_user_flags(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_user_flags;
	py_user_flags = PyInt_FromLong(object->user_flags);
	return py_user_flags;
}

static int py_srvsvc_NetSessInfo1_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->user_flags = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessInfo1_getsetters[] = {
	{ discard_const_p(char, "client"), py_srvsvc_NetSessInfo1_get_client, py_srvsvc_NetSessInfo1_set_client },
	{ discard_const_p(char, "user"), py_srvsvc_NetSessInfo1_get_user, py_srvsvc_NetSessInfo1_set_user },
	{ discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo1_get_num_open, py_srvsvc_NetSessInfo1_set_num_open },
	{ discard_const_p(char, "time"), py_srvsvc_NetSessInfo1_get_time, py_srvsvc_NetSessInfo1_set_time },
	{ discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo1_get_idle_time, py_srvsvc_NetSessInfo1_set_idle_time },
	{ discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo1_get_user_flags, py_srvsvc_NetSessInfo1_set_user_flags },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessInfo1, type);
}


static PyTypeObject srvsvc_NetSessInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessInfo1",
	.tp_getset = py_srvsvc_NetSessInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessInfo1_new,
};


static PyObject *py_srvsvc_NetSessCtr1_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetSessCtr1_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetSessCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetSessInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetSessCtr1_get_count, py_srvsvc_NetSessCtr1_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetSessCtr1_get_array, py_srvsvc_NetSessCtr1_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessCtr1, type);
}


static PyTypeObject srvsvc_NetSessCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessCtr1",
	.tp_getset = py_srvsvc_NetSessCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessCtr1_new,
};


static PyObject *py_srvsvc_NetSessInfo2_get_client(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_client;
	if (object->client == NULL) {
		py_client = Py_None;
		Py_INCREF(py_client);
	} else {
		if (object->client == NULL) {
			py_client = Py_None;
			Py_INCREF(py_client);
		} else {
			py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
		}
	}
	return py_client;
}

static int py_srvsvc_NetSessInfo2_set_client(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client = NULL;
	} else {
		object->client = NULL;
		if (PyUnicode_Check(value)) {
			object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client = 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_srvsvc_NetSessInfo2_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetSessInfo2_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetSessInfo2_get_num_open(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_num_open;
	py_num_open = PyInt_FromLong(object->num_open);
	return py_num_open;
}

static int py_srvsvc_NetSessInfo2_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_open = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo2_get_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_time;
	py_time = PyInt_FromLong(object->time);
	return py_time;
}

static int py_srvsvc_NetSessInfo2_set_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo2_get_idle_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_idle_time;
	py_idle_time = PyInt_FromLong(object->idle_time);
	return py_idle_time;
}

static int py_srvsvc_NetSessInfo2_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->idle_time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo2_get_user_flags(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_user_flags;
	py_user_flags = PyInt_FromLong(object->user_flags);
	return py_user_flags;
}

static int py_srvsvc_NetSessInfo2_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->user_flags = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo2_get_client_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_client_type;
	if (object->client_type == NULL) {
		py_client_type = Py_None;
		Py_INCREF(py_client_type);
	} else {
		if (object->client_type == NULL) {
			py_client_type = Py_None;
			Py_INCREF(py_client_type);
		} else {
			py_client_type = PyUnicode_Decode(object->client_type, strlen(object->client_type), "utf-8", "ignore");
		}
	}
	return py_client_type;
}

static int py_srvsvc_NetSessInfo2_set_client_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client_type = NULL;
	} else {
		object->client_type = NULL;
		if (PyUnicode_Check(value)) {
			object->client_type = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client_type = 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_srvsvc_NetSessInfo2_getsetters[] = {
	{ discard_const_p(char, "client"), py_srvsvc_NetSessInfo2_get_client, py_srvsvc_NetSessInfo2_set_client },
	{ discard_const_p(char, "user"), py_srvsvc_NetSessInfo2_get_user, py_srvsvc_NetSessInfo2_set_user },
	{ discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo2_get_num_open, py_srvsvc_NetSessInfo2_set_num_open },
	{ discard_const_p(char, "time"), py_srvsvc_NetSessInfo2_get_time, py_srvsvc_NetSessInfo2_set_time },
	{ discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo2_get_idle_time, py_srvsvc_NetSessInfo2_set_idle_time },
	{ discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo2_get_user_flags, py_srvsvc_NetSessInfo2_set_user_flags },
	{ discard_const_p(char, "client_type"), py_srvsvc_NetSessInfo2_get_client_type, py_srvsvc_NetSessInfo2_set_client_type },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessInfo2, type);
}


static PyTypeObject srvsvc_NetSessInfo2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessInfo2",
	.tp_getset = py_srvsvc_NetSessInfo2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessInfo2_new,
};


static PyObject *py_srvsvc_NetSessCtr2_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetSessCtr2_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo2_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetSessCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetSessInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessCtr2_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetSessCtr2_get_count, py_srvsvc_NetSessCtr2_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetSessCtr2_get_array, py_srvsvc_NetSessCtr2_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessCtr2, type);
}


static PyTypeObject srvsvc_NetSessCtr2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessCtr2",
	.tp_getset = py_srvsvc_NetSessCtr2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessCtr2_new,
};


static PyObject *py_srvsvc_NetSessInfo10_get_client(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
	PyObject *py_client;
	if (object->client == NULL) {
		py_client = Py_None;
		Py_INCREF(py_client);
	} else {
		if (object->client == NULL) {
			py_client = Py_None;
			Py_INCREF(py_client);
		} else {
			py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
		}
	}
	return py_client;
}

static int py_srvsvc_NetSessInfo10_set_client(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client = NULL;
	} else {
		object->client = NULL;
		if (PyUnicode_Check(value)) {
			object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client = 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_srvsvc_NetSessInfo10_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetSessInfo10_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetSessInfo10_get_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
	PyObject *py_time;
	py_time = PyInt_FromLong(object->time);
	return py_time;
}

static int py_srvsvc_NetSessInfo10_set_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo10_get_idle_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
	PyObject *py_idle_time;
	py_idle_time = PyInt_FromLong(object->idle_time);
	return py_idle_time;
}

static int py_srvsvc_NetSessInfo10_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->idle_time = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessInfo10_getsetters[] = {
	{ discard_const_p(char, "client"), py_srvsvc_NetSessInfo10_get_client, py_srvsvc_NetSessInfo10_set_client },
	{ discard_const_p(char, "user"), py_srvsvc_NetSessInfo10_get_user, py_srvsvc_NetSessInfo10_set_user },
	{ discard_const_p(char, "time"), py_srvsvc_NetSessInfo10_get_time, py_srvsvc_NetSessInfo10_set_time },
	{ discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo10_get_idle_time, py_srvsvc_NetSessInfo10_set_idle_time },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessInfo10_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessInfo10, type);
}


static PyTypeObject srvsvc_NetSessInfo10_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessInfo10",
	.tp_getset = py_srvsvc_NetSessInfo10_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessInfo10_new,
};


static PyObject *py_srvsvc_NetSessCtr10_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetSessCtr10_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo10_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetSessCtr10_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetSessInfo10_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessCtr10_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetSessCtr10_get_count, py_srvsvc_NetSessCtr10_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetSessCtr10_get_array, py_srvsvc_NetSessCtr10_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessCtr10_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessCtr10, type);
}


static PyTypeObject srvsvc_NetSessCtr10_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessCtr10",
	.tp_getset = py_srvsvc_NetSessCtr10_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessCtr10_new,
};


static PyObject *py_srvsvc_NetSessInfo502_get_client(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_client;
	if (object->client == NULL) {
		py_client = Py_None;
		Py_INCREF(py_client);
	} else {
		if (object->client == NULL) {
			py_client = Py_None;
			Py_INCREF(py_client);
		} else {
			py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
		}
	}
	return py_client;
}

static int py_srvsvc_NetSessInfo502_set_client(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client = NULL;
	} else {
		object->client = NULL;
		if (PyUnicode_Check(value)) {
			object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client = 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_srvsvc_NetSessInfo502_get_user(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_user;
	if (object->user == NULL) {
		py_user = Py_None;
		Py_INCREF(py_user);
	} else {
		if (object->user == NULL) {
			py_user = Py_None;
			Py_INCREF(py_user);
		} else {
			py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
		}
	}
	return py_user;
}

static int py_srvsvc_NetSessInfo502_set_user(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user = NULL;
	} else {
		object->user = NULL;
		if (PyUnicode_Check(value)) {
			object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user = 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_srvsvc_NetSessInfo502_get_num_open(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_num_open;
	py_num_open = PyInt_FromLong(object->num_open);
	return py_num_open;
}

static int py_srvsvc_NetSessInfo502_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->num_open = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo502_get_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_time;
	py_time = PyInt_FromLong(object->time);
	return py_time;
}

static int py_srvsvc_NetSessInfo502_set_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo502_get_idle_time(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_idle_time;
	py_idle_time = PyInt_FromLong(object->idle_time);
	return py_idle_time;
}

static int py_srvsvc_NetSessInfo502_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->idle_time = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo502_get_user_flags(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_user_flags;
	py_user_flags = PyInt_FromLong(object->user_flags);
	return py_user_flags;
}

static int py_srvsvc_NetSessInfo502_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->user_flags = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSessInfo502_get_client_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_client_type;
	if (object->client_type == NULL) {
		py_client_type = Py_None;
		Py_INCREF(py_client_type);
	} else {
		if (object->client_type == NULL) {
			py_client_type = Py_None;
			Py_INCREF(py_client_type);
		} else {
			py_client_type = PyUnicode_Decode(object->client_type, strlen(object->client_type), "utf-8", "ignore");
		}
	}
	return py_client_type;
}

static int py_srvsvc_NetSessInfo502_set_client_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->client_type = NULL;
	} else {
		object->client_type = NULL;
		if (PyUnicode_Check(value)) {
			object->client_type = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->client_type = 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_srvsvc_NetSessInfo502_get_transport(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_transport;
	if (object->transport == NULL) {
		py_transport = Py_None;
		Py_INCREF(py_transport);
	} else {
		if (object->transport == NULL) {
			py_transport = Py_None;
			Py_INCREF(py_transport);
		} else {
			py_transport = PyUnicode_Decode(object->transport, strlen(object->transport), "utf-8", "ignore");
		}
	}
	return py_transport;
}

static int py_srvsvc_NetSessInfo502_set_transport(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->transport = NULL;
	} else {
		object->transport = NULL;
		if (PyUnicode_Check(value)) {
			object->transport = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->transport = 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_srvsvc_NetSessInfo502_getsetters[] = {
	{ discard_const_p(char, "client"), py_srvsvc_NetSessInfo502_get_client, py_srvsvc_NetSessInfo502_set_client },
	{ discard_const_p(char, "user"), py_srvsvc_NetSessInfo502_get_user, py_srvsvc_NetSessInfo502_set_user },
	{ discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo502_get_num_open, py_srvsvc_NetSessInfo502_set_num_open },
	{ discard_const_p(char, "time"), py_srvsvc_NetSessInfo502_get_time, py_srvsvc_NetSessInfo502_set_time },
	{ discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo502_get_idle_time, py_srvsvc_NetSessInfo502_set_idle_time },
	{ discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo502_get_user_flags, py_srvsvc_NetSessInfo502_set_user_flags },
	{ discard_const_p(char, "client_type"), py_srvsvc_NetSessInfo502_get_client_type, py_srvsvc_NetSessInfo502_set_client_type },
	{ discard_const_p(char, "transport"), py_srvsvc_NetSessInfo502_get_transport, py_srvsvc_NetSessInfo502_set_transport },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessInfo502, type);
}


static PyTypeObject srvsvc_NetSessInfo502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessInfo502",
	.tp_getset = py_srvsvc_NetSessInfo502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessInfo502_new,
};


static PyObject *py_srvsvc_NetSessCtr502_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetSessCtr502_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo502_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetSessCtr502_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetSessInfo502_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessCtr502_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetSessCtr502_get_count, py_srvsvc_NetSessCtr502_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetSessCtr502_get_array, py_srvsvc_NetSessCtr502_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessCtr502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessCtr502, type);
}


static PyTypeObject srvsvc_NetSessCtr502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessCtr502",
	.tp_getset = py_srvsvc_NetSessCtr502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessCtr502_new,
};

PyObject *py_import_srvsvc_NetSessCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetSessCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->ctr0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSessCtr0_Type, in->ctr0, in->ctr0);
			}
			return ret;

		case 1:
			if (in->ctr1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSessCtr1_Type, in->ctr1, in->ctr1);
			}
			return ret;

		case 2:
			if (in->ctr2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSessCtr2_Type, in->ctr2, in->ctr2);
			}
			return ret;

		case 10:
			if (in->ctr10 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSessCtr10_Type, in->ctr10, in->ctr10);
			}
			return ret;

		case 502:
			if (in->ctr502 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSessCtr502_Type, in->ctr502, in->ctr502);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetSessCtr *py_export_srvsvc_NetSessCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetSessCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetSessCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSessCtr0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr0 = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSessCtr1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1 = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->ctr2 = NULL;
			} else {
				ret->ctr2 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSessCtr2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr2 = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(in);
			}
			break;

		case 10:
			if (in == Py_None) {
				ret->ctr10 = NULL;
			} else {
				ret->ctr10 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSessCtr10_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr10 = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(in);
			}
			break;

		case 502:
			if (in == Py_None) {
				ret->ctr502 = NULL;
			} else {
				ret->ctr502 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSessCtr502_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr502 = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetSessInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetSessInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetSessCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetSessInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetSessCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetSessCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetSessInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetSessInfoCtr_get_level, py_srvsvc_NetSessInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetSessInfoCtr_get_ctr, py_srvsvc_NetSessInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetSessInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSessInfoCtr, type);
}


static PyTypeObject srvsvc_NetSessInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSessInfoCtr",
	.tp_getset = py_srvsvc_NetSessInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSessInfoCtr_new,
};


static PyObject *py_srvsvc_NetShareInfo0_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo0 *object = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetShareInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo0 *object = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetShareInfo0_getsetters[] = {
	{ discard_const_p(char, "name"), py_srvsvc_NetShareInfo0_get_name, py_srvsvc_NetShareInfo0_set_name },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo0, type);
}


static PyTypeObject srvsvc_NetShareInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo0",
	.tp_getset = py_srvsvc_NetShareInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo0_new,
};


static PyObject *py_srvsvc_NetShareCtr0_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr0_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr0_get_count, py_srvsvc_NetShareCtr0_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr0_get_array, py_srvsvc_NetShareCtr0_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr0, type);
}


static PyTypeObject srvsvc_NetShareCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr0",
	.tp_getset = py_srvsvc_NetShareCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr0_new,
};


static PyObject *py_srvsvc_NetShareInfo1_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetShareInfo1_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetShareInfo1_get_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_type;
	py_type = PyInt_FromLong(object->type);
	return py_type;
}

static int py_srvsvc_NetShareInfo1_set_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->type = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->type = 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_srvsvc_NetShareInfo1_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_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_srvsvc_NetShareInfo1_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_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_srvsvc_NetShareInfo1_getsetters[] = {
	{ discard_const_p(char, "name"), py_srvsvc_NetShareInfo1_get_name, py_srvsvc_NetShareInfo1_set_name },
	{ discard_const_p(char, "type"), py_srvsvc_NetShareInfo1_get_type, py_srvsvc_NetShareInfo1_set_type },
	{ discard_const_p(char, "comment"), py_srvsvc_NetShareInfo1_get_comment, py_srvsvc_NetShareInfo1_set_comment },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo1, type);
}


static PyTypeObject srvsvc_NetShareInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo1",
	.tp_getset = py_srvsvc_NetShareInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo1_new,
};


static PyObject *py_srvsvc_NetShareCtr1_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr1_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr1_get_count, py_srvsvc_NetShareCtr1_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr1_get_array, py_srvsvc_NetShareCtr1_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr1, type);
}


static PyTypeObject srvsvc_NetShareCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr1",
	.tp_getset = py_srvsvc_NetShareCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr1_new,
};


static PyObject *py_srvsvc_NetShareInfo2_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetShareInfo2_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetShareInfo2_get_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_type;
	py_type = PyInt_FromLong(object->type);
	return py_type;
}

static int py_srvsvc_NetShareInfo2_set_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->type = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->type = 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_srvsvc_NetShareInfo2_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_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_srvsvc_NetShareInfo2_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_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_srvsvc_NetShareInfo2_get_permissions(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_permissions;
	py_permissions = PyInt_FromLong(object->permissions);
	return py_permissions;
}

static int py_srvsvc_NetShareInfo2_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->permissions = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo2_get_max_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_max_users;
	py_max_users = PyInt_FromLong(object->max_users);
	return py_max_users;
}

static int py_srvsvc_NetShareInfo2_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->max_users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo2_get_current_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_current_users;
	py_current_users = PyInt_FromLong(object->current_users);
	return py_current_users;
}

static int py_srvsvc_NetShareInfo2_set_current_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->current_users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo2_get_path(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_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_srvsvc_NetShareInfo2_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_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_srvsvc_NetShareInfo2_get_password(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_password;
	if (object->password == NULL) {
		py_password = Py_None;
		Py_INCREF(py_password);
	} else {
		if (object->password == NULL) {
			py_password = Py_None;
			Py_INCREF(py_password);
		} else {
			py_password = PyUnicode_Decode(object->password, strlen(object->password), "utf-8", "ignore");
		}
	}
	return py_password;
}

static int py_srvsvc_NetShareInfo2_set_password(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->password = NULL;
	} else {
		object->password = NULL;
		if (PyUnicode_Check(value)) {
			object->password = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->password = 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_srvsvc_NetShareInfo2_getsetters[] = {
	{ discard_const_p(char, "name"), py_srvsvc_NetShareInfo2_get_name, py_srvsvc_NetShareInfo2_set_name },
	{ discard_const_p(char, "type"), py_srvsvc_NetShareInfo2_get_type, py_srvsvc_NetShareInfo2_set_type },
	{ discard_const_p(char, "comment"), py_srvsvc_NetShareInfo2_get_comment, py_srvsvc_NetShareInfo2_set_comment },
	{ discard_const_p(char, "permissions"), py_srvsvc_NetShareInfo2_get_permissions, py_srvsvc_NetShareInfo2_set_permissions },
	{ discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo2_get_max_users, py_srvsvc_NetShareInfo2_set_max_users },
	{ discard_const_p(char, "current_users"), py_srvsvc_NetShareInfo2_get_current_users, py_srvsvc_NetShareInfo2_set_current_users },
	{ discard_const_p(char, "path"), py_srvsvc_NetShareInfo2_get_path, py_srvsvc_NetShareInfo2_set_path },
	{ discard_const_p(char, "password"), py_srvsvc_NetShareInfo2_get_password, py_srvsvc_NetShareInfo2_set_password },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo2, type);
}


static PyTypeObject srvsvc_NetShareInfo2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo2",
	.tp_getset = py_srvsvc_NetShareInfo2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo2_new,
};


static PyObject *py_srvsvc_NetShareCtr2_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr2_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo2_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr2_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr2_get_count, py_srvsvc_NetShareCtr2_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr2_get_array, py_srvsvc_NetShareCtr2_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr2, type);
}


static PyTypeObject srvsvc_NetShareCtr2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr2",
	.tp_getset = py_srvsvc_NetShareCtr2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr2_new,
};


static PyObject *py_srvsvc_NetShareInfo501_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetShareInfo501_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetShareInfo501_get_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
	PyObject *py_type;
	py_type = PyInt_FromLong(object->type);
	return py_type;
}

static int py_srvsvc_NetShareInfo501_set_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->type = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->type = 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_srvsvc_NetShareInfo501_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_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_srvsvc_NetShareInfo501_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_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_srvsvc_NetShareInfo501_get_csc_policy(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
	PyObject *py_csc_policy;
	py_csc_policy = PyInt_FromLong(object->csc_policy);
	return py_csc_policy;
}

static int py_srvsvc_NetShareInfo501_set_csc_policy(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->csc_policy = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareInfo501_getsetters[] = {
	{ discard_const_p(char, "name"), py_srvsvc_NetShareInfo501_get_name, py_srvsvc_NetShareInfo501_set_name },
	{ discard_const_p(char, "type"), py_srvsvc_NetShareInfo501_get_type, py_srvsvc_NetShareInfo501_set_type },
	{ discard_const_p(char, "comment"), py_srvsvc_NetShareInfo501_get_comment, py_srvsvc_NetShareInfo501_set_comment },
	{ discard_const_p(char, "csc_policy"), py_srvsvc_NetShareInfo501_get_csc_policy, py_srvsvc_NetShareInfo501_set_csc_policy },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo501, type);
}


static PyTypeObject srvsvc_NetShareInfo501_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo501",
	.tp_getset = py_srvsvc_NetShareInfo501_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo501_new,
};


static PyObject *py_srvsvc_NetShareCtr501_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr501_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo501_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr501_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo501_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr501_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr501_get_count, py_srvsvc_NetShareCtr501_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr501_get_array, py_srvsvc_NetShareCtr501_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr501, type);
}


static PyTypeObject srvsvc_NetShareCtr501_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr501",
	.tp_getset = py_srvsvc_NetShareCtr501_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr501_new,
};


static PyObject *py_srvsvc_NetShareInfo502_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetShareInfo502_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetShareInfo502_get_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_type;
	py_type = PyInt_FromLong(object->type);
	return py_type;
}

static int py_srvsvc_NetShareInfo502_set_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->type = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->type = 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_srvsvc_NetShareInfo502_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_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_srvsvc_NetShareInfo502_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_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_srvsvc_NetShareInfo502_get_permissions(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_permissions;
	py_permissions = PyInt_FromLong(object->permissions);
	return py_permissions;
}

static int py_srvsvc_NetShareInfo502_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->permissions = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo502_get_max_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_max_users;
	py_max_users = PyInt_FromLong(object->max_users);
	return py_max_users;
}

static int py_srvsvc_NetShareInfo502_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->max_users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo502_get_current_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_current_users;
	py_current_users = PyInt_FromLong(object->current_users);
	return py_current_users;
}

static int py_srvsvc_NetShareInfo502_set_current_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->current_users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo502_get_path(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_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_srvsvc_NetShareInfo502_set_path(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_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_srvsvc_NetShareInfo502_get_password(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_password;
	if (object->password == NULL) {
		py_password = Py_None;
		Py_INCREF(py_password);
	} else {
		if (object->password == NULL) {
			py_password = Py_None;
			Py_INCREF(py_password);
		} else {
			py_password = PyUnicode_Decode(object->password, strlen(object->password), "utf-8", "ignore");
		}
	}
	return py_password;
}

static int py_srvsvc_NetShareInfo502_set_password(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->password = NULL;
	} else {
		object->password = NULL;
		if (PyUnicode_Check(value)) {
			object->password = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->password = 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_srvsvc_NetShareInfo502_get_sd_buf(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_sd_buf;
	py_sd_buf = pytalloc_reference_ex(sec_desc_buf_Type, pytalloc_get_mem_ctx(obj), &object->sd_buf);
	return py_sd_buf;
}

static int py_srvsvc_NetShareInfo502_set_sd_buf(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(sec_desc_buf_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->sd_buf = *(struct sec_desc_buf *)pytalloc_get_ptr(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareInfo502_getsetters[] = {
	{ discard_const_p(char, "name"), py_srvsvc_NetShareInfo502_get_name, py_srvsvc_NetShareInfo502_set_name },
	{ discard_const_p(char, "type"), py_srvsvc_NetShareInfo502_get_type, py_srvsvc_NetShareInfo502_set_type },
	{ discard_const_p(char, "comment"), py_srvsvc_NetShareInfo502_get_comment, py_srvsvc_NetShareInfo502_set_comment },
	{ discard_const_p(char, "permissions"), py_srvsvc_NetShareInfo502_get_permissions, py_srvsvc_NetShareInfo502_set_permissions },
	{ discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo502_get_max_users, py_srvsvc_NetShareInfo502_set_max_users },
	{ discard_const_p(char, "current_users"), py_srvsvc_NetShareInfo502_get_current_users, py_srvsvc_NetShareInfo502_set_current_users },
	{ discard_const_p(char, "path"), py_srvsvc_NetShareInfo502_get_path, py_srvsvc_NetShareInfo502_set_path },
	{ discard_const_p(char, "password"), py_srvsvc_NetShareInfo502_get_password, py_srvsvc_NetShareInfo502_set_password },
	{ discard_const_p(char, "sd_buf"), py_srvsvc_NetShareInfo502_get_sd_buf, py_srvsvc_NetShareInfo502_set_sd_buf },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo502, type);
}


static PyTypeObject srvsvc_NetShareInfo502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo502",
	.tp_getset = py_srvsvc_NetShareInfo502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo502_new,
};


static PyObject *py_srvsvc_NetShareCtr502_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr502_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo502_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr502_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo502_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr502_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr502_get_count, py_srvsvc_NetShareCtr502_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr502_get_array, py_srvsvc_NetShareCtr502_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr502, type);
}


static PyTypeObject srvsvc_NetShareCtr502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr502",
	.tp_getset = py_srvsvc_NetShareCtr502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr502_new,
};


static PyObject *py_srvsvc_NetShareInfo1004_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1004 *object = (struct srvsvc_NetShareInfo1004 *)pytalloc_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_srvsvc_NetShareInfo1004_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1004 *object = (struct srvsvc_NetShareInfo1004 *)pytalloc_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_srvsvc_NetShareInfo1004_getsetters[] = {
	{ discard_const_p(char, "comment"), py_srvsvc_NetShareInfo1004_get_comment, py_srvsvc_NetShareInfo1004_set_comment },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo1004_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo1004, type);
}


static PyTypeObject srvsvc_NetShareInfo1004_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo1004",
	.tp_getset = py_srvsvc_NetShareInfo1004_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo1004_new,
};


static PyObject *py_srvsvc_NetShareCtr1004_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr1004_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1004_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr1004_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1004_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr1004_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr1004_get_count, py_srvsvc_NetShareCtr1004_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr1004_get_array, py_srvsvc_NetShareCtr1004_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr1004_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr1004, type);
}


static PyTypeObject srvsvc_NetShareCtr1004_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr1004",
	.tp_getset = py_srvsvc_NetShareCtr1004_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr1004_new,
};


static PyObject *py_srvsvc_NetShareInfo1005_get_dfs_flags(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1005 *object = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(obj);
	PyObject *py_dfs_flags;
	py_dfs_flags = PyInt_FromLong(object->dfs_flags);
	return py_dfs_flags;
}

static int py_srvsvc_NetShareInfo1005_set_dfs_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1005 *object = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->dfs_flags = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->dfs_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_srvsvc_NetShareInfo1005_getsetters[] = {
	{ discard_const_p(char, "dfs_flags"), py_srvsvc_NetShareInfo1005_get_dfs_flags, py_srvsvc_NetShareInfo1005_set_dfs_flags },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo1005, type);
}


static PyTypeObject srvsvc_NetShareInfo1005_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo1005",
	.tp_getset = py_srvsvc_NetShareInfo1005_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo1005_new,
};


static PyObject *py_srvsvc_NetShareCtr1005_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr1005_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1005_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr1005_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1005_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr1005_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr1005_get_count, py_srvsvc_NetShareCtr1005_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr1005_get_array, py_srvsvc_NetShareCtr1005_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr1005, type);
}


static PyTypeObject srvsvc_NetShareCtr1005_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr1005",
	.tp_getset = py_srvsvc_NetShareCtr1005_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr1005_new,
};


static PyObject *py_srvsvc_NetShareInfo1006_get_max_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1006 *object = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(obj);
	PyObject *py_max_users;
	py_max_users = PyInt_FromLong(object->max_users);
	return py_max_users;
}

static int py_srvsvc_NetShareInfo1006_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1006 *object = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->max_users = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareInfo1006_getsetters[] = {
	{ discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo1006_get_max_users, py_srvsvc_NetShareInfo1006_set_max_users },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo1006_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo1006, type);
}


static PyTypeObject srvsvc_NetShareInfo1006_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo1006",
	.tp_getset = py_srvsvc_NetShareInfo1006_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo1006_new,
};


static PyObject *py_srvsvc_NetShareCtr1006_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr1006_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1006_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr1006_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1006_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr1006_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr1006_get_count, py_srvsvc_NetShareCtr1006_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr1006_get_array, py_srvsvc_NetShareCtr1006_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr1006_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr1006, type);
}


static PyTypeObject srvsvc_NetShareCtr1006_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr1006",
	.tp_getset = py_srvsvc_NetShareCtr1006_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr1006_new,
};


static PyObject *py_srvsvc_NetShareInfo1007_get_flags(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyInt_FromLong(object->flags);
	return py_flags;
}

static int py_srvsvc_NetShareInfo1007_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->flags = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetShareInfo1007_get_alternate_directory_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(obj);
	PyObject *py_alternate_directory_name;
	if (object->alternate_directory_name == NULL) {
		py_alternate_directory_name = Py_None;
		Py_INCREF(py_alternate_directory_name);
	} else {
		if (object->alternate_directory_name == NULL) {
			py_alternate_directory_name = Py_None;
			Py_INCREF(py_alternate_directory_name);
		} else {
			py_alternate_directory_name = PyUnicode_Decode(object->alternate_directory_name, strlen(object->alternate_directory_name), "utf-8", "ignore");
		}
	}
	return py_alternate_directory_name;
}

static int py_srvsvc_NetShareInfo1007_set_alternate_directory_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->alternate_directory_name = NULL;
	} else {
		object->alternate_directory_name = NULL;
		if (PyUnicode_Check(value)) {
			object->alternate_directory_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->alternate_directory_name = 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_srvsvc_NetShareInfo1007_getsetters[] = {
	{ discard_const_p(char, "flags"), py_srvsvc_NetShareInfo1007_get_flags, py_srvsvc_NetShareInfo1007_set_flags },
	{ discard_const_p(char, "alternate_directory_name"), py_srvsvc_NetShareInfo1007_get_alternate_directory_name, py_srvsvc_NetShareInfo1007_set_alternate_directory_name },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfo1007_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfo1007, type);
}


static PyTypeObject srvsvc_NetShareInfo1007_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfo1007",
	.tp_getset = py_srvsvc_NetShareInfo1007_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfo1007_new,
};


static PyObject *py_srvsvc_NetShareCtr1007_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr1007_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1007_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr1007_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1007_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr1007_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr1007_get_count, py_srvsvc_NetShareCtr1007_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr1007_get_array, py_srvsvc_NetShareCtr1007_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr1007_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr1007, type);
}


static PyTypeObject srvsvc_NetShareCtr1007_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr1007",
	.tp_getset = py_srvsvc_NetShareCtr1007_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr1007_new,
};


static PyObject *py_srvsvc_NetShareCtr1501_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetShareCtr1501_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(sec_desc_buf_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetShareCtr1501_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(sec_desc_buf_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct sec_desc_buf *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareCtr1501_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetShareCtr1501_get_count, py_srvsvc_NetShareCtr1501_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetShareCtr1501_get_array, py_srvsvc_NetShareCtr1501_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareCtr1501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareCtr1501, type);
}


static PyTypeObject srvsvc_NetShareCtr1501_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareCtr1501",
	.tp_getset = py_srvsvc_NetShareCtr1501_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareCtr1501_new,
};

PyObject *py_import_srvsvc_NetShareInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetShareInfo *in)
{
	PyObject *ret;

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

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

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

		case 501:
			if (in->info501 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareInfo501_Type, in->info501, in->info501);
			}
			return ret;

		case 502:
			if (in->info502 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareInfo502_Type, in->info502, in->info502);
			}
			return ret;

		case 1004:
			if (in->info1004 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1004_Type, in->info1004, in->info1004);
			}
			return ret;

		case 1005:
			if (in->info1005 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1005_Type, in->info1005, in->info1005);
			}
			return ret;

		case 1006:
			if (in->info1006 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1006_Type, in->info1006, in->info1006);
			}
			return ret;

		case 1007:
			if (in->info1007 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1007_Type, in->info1007, in->info1007);
			}
			return ret;

		case 1501:
			if (in->info1501 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(sec_desc_buf_Type, in->info1501, in->info1501);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetShareInfo *py_export_srvsvc_NetShareInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetShareInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetShareInfo);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->info0 = NULL;
			} else {
				ret->info0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info0 = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1 = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->info2 = NULL;
			} else {
				ret->info2 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info2 = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(in);
			}
			break;

		case 501:
			if (in == Py_None) {
				ret->info501 = NULL;
			} else {
				ret->info501 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo501_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info501 = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(in);
			}
			break;

		case 502:
			if (in == Py_None) {
				ret->info502 = NULL;
			} else {
				ret->info502 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo502_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info502 = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(in);
			}
			break;

		case 1004:
			if (in == Py_None) {
				ret->info1004 = NULL;
			} else {
				ret->info1004 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1004_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1004 = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(in);
			}
			break;

		case 1005:
			if (in == Py_None) {
				ret->info1005 = NULL;
			} else {
				ret->info1005 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1005_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1005 = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(in);
			}
			break;

		case 1006:
			if (in == Py_None) {
				ret->info1006 = NULL;
			} else {
				ret->info1006 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1006_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1006 = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(in);
			}
			break;

		case 1007:
			if (in == Py_None) {
				ret->info1007 = NULL;
			} else {
				ret->info1007 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareInfo1007_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1007 = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(in);
			}
			break;

		case 1501:
			if (in == Py_None) {
				ret->info1501 = NULL;
			} else {
				ret->info1501 = NULL;
				PY_CHECK_TYPE(sec_desc_buf_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1501 = (struct sec_desc_buf *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}

PyObject *py_import_srvsvc_NetShareCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetShareCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->ctr0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr0_Type, in->ctr0, in->ctr0);
			}
			return ret;

		case 1:
			if (in->ctr1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1_Type, in->ctr1, in->ctr1);
			}
			return ret;

		case 2:
			if (in->ctr2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr2_Type, in->ctr2, in->ctr2);
			}
			return ret;

		case 501:
			if (in->ctr501 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr501_Type, in->ctr501, in->ctr501);
			}
			return ret;

		case 502:
			if (in->ctr502 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr502_Type, in->ctr502, in->ctr502);
			}
			return ret;

		case 1004:
			if (in->ctr1004 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1004_Type, in->ctr1004, in->ctr1004);
			}
			return ret;

		case 1005:
			if (in->ctr1005 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1005_Type, in->ctr1005, in->ctr1005);
			}
			return ret;

		case 1006:
			if (in->ctr1006 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1006_Type, in->ctr1006, in->ctr1006);
			}
			return ret;

		case 1007:
			if (in->ctr1007 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1007_Type, in->ctr1007, in->ctr1007);
			}
			return ret;

		case 1501:
			if (in->ctr1501 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1501_Type, in->ctr1501, in->ctr1501);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetShareCtr *py_export_srvsvc_NetShareCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetShareCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetShareCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr0 = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1 = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->ctr2 = NULL;
			} else {
				ret->ctr2 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr2 = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(in);
			}
			break;

		case 501:
			if (in == Py_None) {
				ret->ctr501 = NULL;
			} else {
				ret->ctr501 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr501_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr501 = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(in);
			}
			break;

		case 502:
			if (in == Py_None) {
				ret->ctr502 = NULL;
			} else {
				ret->ctr502 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr502_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr502 = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(in);
			}
			break;

		case 1004:
			if (in == Py_None) {
				ret->ctr1004 = NULL;
			} else {
				ret->ctr1004 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr1004_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1004 = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(in);
			}
			break;

		case 1005:
			if (in == Py_None) {
				ret->ctr1005 = NULL;
			} else {
				ret->ctr1005 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr1005_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1005 = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(in);
			}
			break;

		case 1006:
			if (in == Py_None) {
				ret->ctr1006 = NULL;
			} else {
				ret->ctr1006 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr1006_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1006 = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(in);
			}
			break;

		case 1007:
			if (in == Py_None) {
				ret->ctr1007 = NULL;
			} else {
				ret->ctr1007 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr1007_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1007 = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(in);
			}
			break;

		case 1501:
			if (in == Py_None) {
				ret->ctr1501 = NULL;
			} else {
				ret->ctr1501 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetShareCtr1501_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1501 = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetShareInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetShareInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetShareCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetShareInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetShareCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetShareCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetShareInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetShareInfoCtr_get_level, py_srvsvc_NetShareInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetShareInfoCtr_get_ctr, py_srvsvc_NetShareInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetShareInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetShareInfoCtr, type);
}


static PyTypeObject srvsvc_NetShareInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetShareInfoCtr",
	.tp_getset = py_srvsvc_NetShareInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetShareInfoCtr_new,
};


static PyObject *py_srvsvc_NetSrvInfo100_get_platform_id(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(obj);
	PyObject *py_platform_id;
	py_platform_id = PyInt_FromLong(object->platform_id);
	return py_platform_id;
}

static int py_srvsvc_NetSrvInfo100_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->platform_id = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->platform_id = 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_srvsvc_NetSrvInfo100_get_server_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(obj);
	PyObject *py_server_name;
	if (object->server_name == NULL) {
		py_server_name = Py_None;
		Py_INCREF(py_server_name);
	} else {
		if (object->server_name == NULL) {
			py_server_name = Py_None;
			Py_INCREF(py_server_name);
		} else {
			py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
		}
	}
	return py_server_name;
}

static int py_srvsvc_NetSrvInfo100_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->server_name = NULL;
	} else {
		object->server_name = NULL;
		if (PyUnicode_Check(value)) {
			object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->server_name = 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_srvsvc_NetSrvInfo100_getsetters[] = {
	{ discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo100_get_platform_id, py_srvsvc_NetSrvInfo100_set_platform_id },
	{ discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo100_get_server_name, py_srvsvc_NetSrvInfo100_set_server_name },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo100_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo100, type);
}

static PyObject *py_srvsvc_NetSrvInfo100_ndr_pack(PyObject *py_obj)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob;
	enum ndr_err_code err;
	err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvInfo100);
	if (err != NDR_ERR_SUCCESS) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	return PyString_FromStringAndSize((char *)blob.data, blob.length);
}

static PyObject *py_srvsvc_NetSrvInfo100_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob;
	int blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo100);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo100);
	}
	if (err != NDR_ERR_SUCCESS) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_srvsvc_NetSrvInfo100_ndr_print(PyObject *py_obj)
{
	struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_srvsvc_NetSrvInfo100, "srvsvc_NetSrvInfo100", object);
	ret = PyString_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_srvsvc_NetSrvInfo100_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject srvsvc_NetSrvInfo100_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo100",
	.tp_getset = py_srvsvc_NetSrvInfo100_getsetters,
	.tp_methods = py_srvsvc_NetSrvInfo100_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo100_new,
};


static PyObject *py_srvsvc_NetSrvInfo101_get_platform_id(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_platform_id;
	py_platform_id = PyInt_FromLong(object->platform_id);
	return py_platform_id;
}

static int py_srvsvc_NetSrvInfo101_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->platform_id = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->platform_id = 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_srvsvc_NetSrvInfo101_get_server_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_server_name;
	if (object->server_name == NULL) {
		py_server_name = Py_None;
		Py_INCREF(py_server_name);
	} else {
		if (object->server_name == NULL) {
			py_server_name = Py_None;
			Py_INCREF(py_server_name);
		} else {
			py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
		}
	}
	return py_server_name;
}

static int py_srvsvc_NetSrvInfo101_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->server_name = NULL;
	} else {
		object->server_name = NULL;
		if (PyUnicode_Check(value)) {
			object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->server_name = 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_srvsvc_NetSrvInfo101_get_version_major(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_version_major;
	py_version_major = PyInt_FromLong(object->version_major);
	return py_version_major;
}

static int py_srvsvc_NetSrvInfo101_set_version_major(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->version_major = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo101_get_version_minor(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_version_minor;
	py_version_minor = PyInt_FromLong(object->version_minor);
	return py_version_minor;
}

static int py_srvsvc_NetSrvInfo101_set_version_minor(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->version_minor = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo101_get_server_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_server_type;
	py_server_type = PyInt_FromLong(object->server_type);
	return py_server_type;
}

static int py_srvsvc_NetSrvInfo101_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->server_type = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->server_type = 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_srvsvc_NetSrvInfo101_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_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_srvsvc_NetSrvInfo101_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_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_srvsvc_NetSrvInfo101_getsetters[] = {
	{ discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo101_get_platform_id, py_srvsvc_NetSrvInfo101_set_platform_id },
	{ discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo101_get_server_name, py_srvsvc_NetSrvInfo101_set_server_name },
	{ discard_const_p(char, "version_major"), py_srvsvc_NetSrvInfo101_get_version_major, py_srvsvc_NetSrvInfo101_set_version_major },
	{ discard_const_p(char, "version_minor"), py_srvsvc_NetSrvInfo101_get_version_minor, py_srvsvc_NetSrvInfo101_set_version_minor },
	{ discard_const_p(char, "server_type"), py_srvsvc_NetSrvInfo101_get_server_type, py_srvsvc_NetSrvInfo101_set_server_type },
	{ discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo101_get_comment, py_srvsvc_NetSrvInfo101_set_comment },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo101_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo101, type);
}

static PyObject *py_srvsvc_NetSrvInfo101_ndr_pack(PyObject *py_obj)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob;
	enum ndr_err_code err;
	err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvInfo101);
	if (err != NDR_ERR_SUCCESS) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	return PyString_FromStringAndSize((char *)blob.data, blob.length);
}

static PyObject *py_srvsvc_NetSrvInfo101_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob;
	int blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo101);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo101);
	}
	if (err != NDR_ERR_SUCCESS) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_srvsvc_NetSrvInfo101_ndr_print(PyObject *py_obj)
{
	struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_srvsvc_NetSrvInfo101, "srvsvc_NetSrvInfo101", object);
	ret = PyString_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_srvsvc_NetSrvInfo101_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject srvsvc_NetSrvInfo101_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo101",
	.tp_getset = py_srvsvc_NetSrvInfo101_getsetters,
	.tp_methods = py_srvsvc_NetSrvInfo101_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo101_new,
};


static PyObject *py_srvsvc_NetSrvInfo102_get_platform_id(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_platform_id;
	py_platform_id = PyInt_FromLong(object->platform_id);
	return py_platform_id;
}

static int py_srvsvc_NetSrvInfo102_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->platform_id = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->platform_id = 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_srvsvc_NetSrvInfo102_get_server_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_server_name;
	if (object->server_name == NULL) {
		py_server_name = Py_None;
		Py_INCREF(py_server_name);
	} else {
		if (object->server_name == NULL) {
			py_server_name = Py_None;
			Py_INCREF(py_server_name);
		} else {
			py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
		}
	}
	return py_server_name;
}

static int py_srvsvc_NetSrvInfo102_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->server_name = NULL;
	} else {
		object->server_name = NULL;
		if (PyUnicode_Check(value)) {
			object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->server_name = 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_srvsvc_NetSrvInfo102_get_version_major(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_version_major;
	py_version_major = PyInt_FromLong(object->version_major);
	return py_version_major;
}

static int py_srvsvc_NetSrvInfo102_set_version_major(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->version_major = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_version_minor(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_version_minor;
	py_version_minor = PyInt_FromLong(object->version_minor);
	return py_version_minor;
}

static int py_srvsvc_NetSrvInfo102_set_version_minor(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->version_minor = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_server_type(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_server_type;
	py_server_type = PyInt_FromLong(object->server_type);
	return py_server_type;
}

static int py_srvsvc_NetSrvInfo102_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->server_type = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->server_type = 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_srvsvc_NetSrvInfo102_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_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_srvsvc_NetSrvInfo102_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_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_srvsvc_NetSrvInfo102_get_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_users;
	py_users = PyInt_FromLong(object->users);
	return py_users;
}

static int py_srvsvc_NetSrvInfo102_set_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->users = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_disc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_disc;
	py_disc = PyInt_FromLong(object->disc);
	return py_disc;
}

static int py_srvsvc_NetSrvInfo102_set_disc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->disc = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_hidden(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_hidden;
	py_hidden = PyInt_FromLong(object->hidden);
	return py_hidden;
}

static int py_srvsvc_NetSrvInfo102_set_hidden(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->hidden = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_announce(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_announce;
	py_announce = PyInt_FromLong(object->announce);
	return py_announce;
}

static int py_srvsvc_NetSrvInfo102_set_announce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->announce = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_anndelta(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_anndelta;
	py_anndelta = PyInt_FromLong(object->anndelta);
	return py_anndelta;
}

static int py_srvsvc_NetSrvInfo102_set_anndelta(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->anndelta = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_licenses(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_licenses;
	py_licenses = PyInt_FromLong(object->licenses);
	return py_licenses;
}

static int py_srvsvc_NetSrvInfo102_set_licenses(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->licenses = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo102_get_userpath(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_userpath;
	if (object->userpath == NULL) {
		py_userpath = Py_None;
		Py_INCREF(py_userpath);
	} else {
		if (object->userpath == NULL) {
			py_userpath = Py_None;
			Py_INCREF(py_userpath);
		} else {
			py_userpath = PyUnicode_Decode(object->userpath, strlen(object->userpath), "utf-8", "ignore");
		}
	}
	return py_userpath;
}

static int py_srvsvc_NetSrvInfo102_set_userpath(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->userpath = NULL;
	} else {
		object->userpath = NULL;
		if (PyUnicode_Check(value)) {
			object->userpath = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->userpath = 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_srvsvc_NetSrvInfo102_getsetters[] = {
	{ discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo102_get_platform_id, py_srvsvc_NetSrvInfo102_set_platform_id },
	{ discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo102_get_server_name, py_srvsvc_NetSrvInfo102_set_server_name },
	{ discard_const_p(char, "version_major"), py_srvsvc_NetSrvInfo102_get_version_major, py_srvsvc_NetSrvInfo102_set_version_major },
	{ discard_const_p(char, "version_minor"), py_srvsvc_NetSrvInfo102_get_version_minor, py_srvsvc_NetSrvInfo102_set_version_minor },
	{ discard_const_p(char, "server_type"), py_srvsvc_NetSrvInfo102_get_server_type, py_srvsvc_NetSrvInfo102_set_server_type },
	{ discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo102_get_comment, py_srvsvc_NetSrvInfo102_set_comment },
	{ discard_const_p(char, "users"), py_srvsvc_NetSrvInfo102_get_users, py_srvsvc_NetSrvInfo102_set_users },
	{ discard_const_p(char, "disc"), py_srvsvc_NetSrvInfo102_get_disc, py_srvsvc_NetSrvInfo102_set_disc },
	{ discard_const_p(char, "hidden"), py_srvsvc_NetSrvInfo102_get_hidden, py_srvsvc_NetSrvInfo102_set_hidden },
	{ discard_const_p(char, "announce"), py_srvsvc_NetSrvInfo102_get_announce, py_srvsvc_NetSrvInfo102_set_announce },
	{ discard_const_p(char, "anndelta"), py_srvsvc_NetSrvInfo102_get_anndelta, py_srvsvc_NetSrvInfo102_set_anndelta },
	{ discard_const_p(char, "licenses"), py_srvsvc_NetSrvInfo102_get_licenses, py_srvsvc_NetSrvInfo102_set_licenses },
	{ discard_const_p(char, "userpath"), py_srvsvc_NetSrvInfo102_get_userpath, py_srvsvc_NetSrvInfo102_set_userpath },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo102_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo102, type);
}


static PyTypeObject srvsvc_NetSrvInfo102_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo102",
	.tp_getset = py_srvsvc_NetSrvInfo102_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo102_new,
};


static PyObject *py_srvsvc_NetSrvInfo402_get_ulist_mtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_ulist_mtime;
	py_ulist_mtime = PyInt_FromLong(object->ulist_mtime);
	return py_ulist_mtime;
}

static int py_srvsvc_NetSrvInfo402_set_ulist_mtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->ulist_mtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_glist_mtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_glist_mtime;
	py_glist_mtime = PyInt_FromLong(object->glist_mtime);
	return py_glist_mtime;
}

static int py_srvsvc_NetSrvInfo402_set_glist_mtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->glist_mtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_alist_mtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_alist_mtime;
	py_alist_mtime = PyInt_FromLong(object->alist_mtime);
	return py_alist_mtime;
}

static int py_srvsvc_NetSrvInfo402_set_alist_mtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->alist_mtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_alerts(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_alerts;
	if (object->alerts == NULL) {
		py_alerts = Py_None;
		Py_INCREF(py_alerts);
	} else {
		if (object->alerts == NULL) {
			py_alerts = Py_None;
			Py_INCREF(py_alerts);
		} else {
			py_alerts = PyUnicode_Decode(object->alerts, strlen(object->alerts), "utf-8", "ignore");
		}
	}
	return py_alerts;
}

static int py_srvsvc_NetSrvInfo402_set_alerts(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->alerts = NULL;
	} else {
		object->alerts = NULL;
		if (PyUnicode_Check(value)) {
			object->alerts = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->alerts = 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_srvsvc_NetSrvInfo402_get_security(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_security;
	py_security = PyInt_FromLong(object->security);
	return py_security;
}

static int py_srvsvc_NetSrvInfo402_set_security(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->security = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_numadmin(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_numadmin;
	py_numadmin = PyInt_FromLong(object->numadmin);
	return py_numadmin;
}

static int py_srvsvc_NetSrvInfo402_set_numadmin(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numadmin = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_lanmask(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_lanmask;
	py_lanmask = PyInt_FromLong(object->lanmask);
	return py_lanmask;
}

static int py_srvsvc_NetSrvInfo402_set_lanmask(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->lanmask = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_guestaccount(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_guestaccount;
	if (object->guestaccount == NULL) {
		py_guestaccount = Py_None;
		Py_INCREF(py_guestaccount);
	} else {
		if (object->guestaccount == NULL) {
			py_guestaccount = Py_None;
			Py_INCREF(py_guestaccount);
		} else {
			py_guestaccount = PyUnicode_Decode(object->guestaccount, strlen(object->guestaccount), "utf-8", "ignore");
		}
	}
	return py_guestaccount;
}

static int py_srvsvc_NetSrvInfo402_set_guestaccount(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->guestaccount = NULL;
	} else {
		object->guestaccount = NULL;
		if (PyUnicode_Check(value)) {
			object->guestaccount = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->guestaccount = 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_srvsvc_NetSrvInfo402_get_chdevs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_chdevs;
	py_chdevs = PyInt_FromLong(object->chdevs);
	return py_chdevs;
}

static int py_srvsvc_NetSrvInfo402_set_chdevs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->chdevs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_chdevqs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_chdevqs;
	py_chdevqs = PyInt_FromLong(object->chdevqs);
	return py_chdevqs;
}

static int py_srvsvc_NetSrvInfo402_set_chdevqs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->chdevqs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_chdevjobs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_chdevjobs;
	py_chdevjobs = PyInt_FromLong(object->chdevjobs);
	return py_chdevjobs;
}

static int py_srvsvc_NetSrvInfo402_set_chdevjobs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->chdevjobs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_connections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_connections;
	py_connections = PyInt_FromLong(object->connections);
	return py_connections;
}

static int py_srvsvc_NetSrvInfo402_set_connections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->connections = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_shares(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_shares;
	py_shares = PyInt_FromLong(object->shares);
	return py_shares;
}

static int py_srvsvc_NetSrvInfo402_set_shares(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->shares = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_openfiles(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_openfiles;
	py_openfiles = PyInt_FromLong(object->openfiles);
	return py_openfiles;
}

static int py_srvsvc_NetSrvInfo402_set_openfiles(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->openfiles = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_sessopen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_sessopen;
	py_sessopen = PyInt_FromLong(object->sessopen);
	return py_sessopen;
}

static int py_srvsvc_NetSrvInfo402_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessopen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_sesssvc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_sesssvc;
	py_sesssvc = PyInt_FromLong(object->sesssvc);
	return py_sesssvc;
}

static int py_srvsvc_NetSrvInfo402_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sesssvc = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_sessreqs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_sessreqs;
	py_sessreqs = PyInt_FromLong(object->sessreqs);
	return py_sessreqs;
}

static int py_srvsvc_NetSrvInfo402_set_sessreqs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessreqs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_opensearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_opensearch;
	py_opensearch = PyInt_FromLong(object->opensearch);
	return py_opensearch;
}

static int py_srvsvc_NetSrvInfo402_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->opensearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_activelocks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_activelocks;
	py_activelocks = PyInt_FromLong(object->activelocks);
	return py_activelocks;
}

static int py_srvsvc_NetSrvInfo402_set_activelocks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->activelocks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_numreqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_numreqbufs;
	py_numreqbufs = PyInt_FromLong(object->numreqbufs);
	return py_numreqbufs;
}

static int py_srvsvc_NetSrvInfo402_set_numreqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numreqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_sizereqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_sizereqbufs;
	py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
	return py_sizereqbufs;
}

static int py_srvsvc_NetSrvInfo402_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sizereqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_numbigbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_numbigbufs;
	py_numbigbufs = PyInt_FromLong(object->numbigbufs);
	return py_numbigbufs;
}

static int py_srvsvc_NetSrvInfo402_set_numbigbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numbigbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_numfiletasks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_numfiletasks;
	py_numfiletasks = PyInt_FromLong(object->numfiletasks);
	return py_numfiletasks;
}

static int py_srvsvc_NetSrvInfo402_set_numfiletasks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numfiletasks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_alertsched(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_alertsched;
	py_alertsched = PyInt_FromLong(object->alertsched);
	return py_alertsched;
}

static int py_srvsvc_NetSrvInfo402_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->alertsched = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_erroralert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_erroralert;
	py_erroralert = PyInt_FromLong(object->erroralert);
	return py_erroralert;
}

static int py_srvsvc_NetSrvInfo402_set_erroralert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->erroralert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_logonalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_logonalert;
	py_logonalert = PyInt_FromLong(object->logonalert);
	return py_logonalert;
}

static int py_srvsvc_NetSrvInfo402_set_logonalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->logonalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_accessalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_accessalert;
	py_accessalert = PyInt_FromLong(object->accessalert);
	return py_accessalert;
}

static int py_srvsvc_NetSrvInfo402_set_accessalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->accessalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_diskalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_diskalert;
	py_diskalert = PyInt_FromLong(object->diskalert);
	return py_diskalert;
}

static int py_srvsvc_NetSrvInfo402_set_diskalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->diskalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_netioalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_netioalert;
	py_netioalert = PyInt_FromLong(object->netioalert);
	return py_netioalert;
}

static int py_srvsvc_NetSrvInfo402_set_netioalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->netioalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_maxaudits(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_maxaudits;
	py_maxaudits = PyInt_FromLong(object->maxaudits);
	return py_maxaudits;
}

static int py_srvsvc_NetSrvInfo402_set_maxaudits(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxaudits = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo402_get_srvheuristics(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
	PyObject *py_srvheuristics;
	if (object->srvheuristics == NULL) {
		py_srvheuristics = Py_None;
		Py_INCREF(py_srvheuristics);
	} else {
		if (object->srvheuristics == NULL) {
			py_srvheuristics = Py_None;
			Py_INCREF(py_srvheuristics);
		} else {
			py_srvheuristics = PyUnicode_Decode(object->srvheuristics, strlen(object->srvheuristics), "utf-8", "ignore");
		}
	}
	return py_srvheuristics;
}

static int py_srvsvc_NetSrvInfo402_set_srvheuristics(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->srvheuristics = NULL;
	} else {
		object->srvheuristics = NULL;
		if (PyUnicode_Check(value)) {
			object->srvheuristics = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->srvheuristics = 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_srvsvc_NetSrvInfo402_getsetters[] = {
	{ discard_const_p(char, "ulist_mtime"), py_srvsvc_NetSrvInfo402_get_ulist_mtime, py_srvsvc_NetSrvInfo402_set_ulist_mtime },
	{ discard_const_p(char, "glist_mtime"), py_srvsvc_NetSrvInfo402_get_glist_mtime, py_srvsvc_NetSrvInfo402_set_glist_mtime },
	{ discard_const_p(char, "alist_mtime"), py_srvsvc_NetSrvInfo402_get_alist_mtime, py_srvsvc_NetSrvInfo402_set_alist_mtime },
	{ discard_const_p(char, "alerts"), py_srvsvc_NetSrvInfo402_get_alerts, py_srvsvc_NetSrvInfo402_set_alerts },
	{ discard_const_p(char, "security"), py_srvsvc_NetSrvInfo402_get_security, py_srvsvc_NetSrvInfo402_set_security },
	{ discard_const_p(char, "numadmin"), py_srvsvc_NetSrvInfo402_get_numadmin, py_srvsvc_NetSrvInfo402_set_numadmin },
	{ discard_const_p(char, "lanmask"), py_srvsvc_NetSrvInfo402_get_lanmask, py_srvsvc_NetSrvInfo402_set_lanmask },
	{ discard_const_p(char, "guestaccount"), py_srvsvc_NetSrvInfo402_get_guestaccount, py_srvsvc_NetSrvInfo402_set_guestaccount },
	{ discard_const_p(char, "chdevs"), py_srvsvc_NetSrvInfo402_get_chdevs, py_srvsvc_NetSrvInfo402_set_chdevs },
	{ discard_const_p(char, "chdevqs"), py_srvsvc_NetSrvInfo402_get_chdevqs, py_srvsvc_NetSrvInfo402_set_chdevqs },
	{ discard_const_p(char, "chdevjobs"), py_srvsvc_NetSrvInfo402_get_chdevjobs, py_srvsvc_NetSrvInfo402_set_chdevjobs },
	{ discard_const_p(char, "connections"), py_srvsvc_NetSrvInfo402_get_connections, py_srvsvc_NetSrvInfo402_set_connections },
	{ discard_const_p(char, "shares"), py_srvsvc_NetSrvInfo402_get_shares, py_srvsvc_NetSrvInfo402_set_shares },
	{ discard_const_p(char, "openfiles"), py_srvsvc_NetSrvInfo402_get_openfiles, py_srvsvc_NetSrvInfo402_set_openfiles },
	{ discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo402_get_sessopen, py_srvsvc_NetSrvInfo402_set_sessopen },
	{ discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo402_get_sesssvc, py_srvsvc_NetSrvInfo402_set_sesssvc },
	{ discard_const_p(char, "sessreqs"), py_srvsvc_NetSrvInfo402_get_sessreqs, py_srvsvc_NetSrvInfo402_set_sessreqs },
	{ discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo402_get_opensearch, py_srvsvc_NetSrvInfo402_set_opensearch },
	{ discard_const_p(char, "activelocks"), py_srvsvc_NetSrvInfo402_get_activelocks, py_srvsvc_NetSrvInfo402_set_activelocks },
	{ discard_const_p(char, "numreqbufs"), py_srvsvc_NetSrvInfo402_get_numreqbufs, py_srvsvc_NetSrvInfo402_set_numreqbufs },
	{ discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo402_get_sizereqbufs, py_srvsvc_NetSrvInfo402_set_sizereqbufs },
	{ discard_const_p(char, "numbigbufs"), py_srvsvc_NetSrvInfo402_get_numbigbufs, py_srvsvc_NetSrvInfo402_set_numbigbufs },
	{ discard_const_p(char, "numfiletasks"), py_srvsvc_NetSrvInfo402_get_numfiletasks, py_srvsvc_NetSrvInfo402_set_numfiletasks },
	{ discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo402_get_alertsched, py_srvsvc_NetSrvInfo402_set_alertsched },
	{ discard_const_p(char, "erroralert"), py_srvsvc_NetSrvInfo402_get_erroralert, py_srvsvc_NetSrvInfo402_set_erroralert },
	{ discard_const_p(char, "logonalert"), py_srvsvc_NetSrvInfo402_get_logonalert, py_srvsvc_NetSrvInfo402_set_logonalert },
	{ discard_const_p(char, "accessalert"), py_srvsvc_NetSrvInfo402_get_accessalert, py_srvsvc_NetSrvInfo402_set_accessalert },
	{ discard_const_p(char, "diskalert"), py_srvsvc_NetSrvInfo402_get_diskalert, py_srvsvc_NetSrvInfo402_set_diskalert },
	{ discard_const_p(char, "netioalert"), py_srvsvc_NetSrvInfo402_get_netioalert, py_srvsvc_NetSrvInfo402_set_netioalert },
	{ discard_const_p(char, "maxaudits"), py_srvsvc_NetSrvInfo402_get_maxaudits, py_srvsvc_NetSrvInfo402_set_maxaudits },
	{ discard_const_p(char, "srvheuristics"), py_srvsvc_NetSrvInfo402_get_srvheuristics, py_srvsvc_NetSrvInfo402_set_srvheuristics },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo402_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo402, type);
}


static PyTypeObject srvsvc_NetSrvInfo402_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo402",
	.tp_getset = py_srvsvc_NetSrvInfo402_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo402_new,
};


static PyObject *py_srvsvc_NetSrvInfo403_get_ulist_mtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_ulist_mtime;
	py_ulist_mtime = PyInt_FromLong(object->ulist_mtime);
	return py_ulist_mtime;
}

static int py_srvsvc_NetSrvInfo403_set_ulist_mtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->ulist_mtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_glist_mtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_glist_mtime;
	py_glist_mtime = PyInt_FromLong(object->glist_mtime);
	return py_glist_mtime;
}

static int py_srvsvc_NetSrvInfo403_set_glist_mtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->glist_mtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_alist_mtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_alist_mtime;
	py_alist_mtime = PyInt_FromLong(object->alist_mtime);
	return py_alist_mtime;
}

static int py_srvsvc_NetSrvInfo403_set_alist_mtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->alist_mtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_alerts(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_alerts;
	if (object->alerts == NULL) {
		py_alerts = Py_None;
		Py_INCREF(py_alerts);
	} else {
		if (object->alerts == NULL) {
			py_alerts = Py_None;
			Py_INCREF(py_alerts);
		} else {
			py_alerts = PyUnicode_Decode(object->alerts, strlen(object->alerts), "utf-8", "ignore");
		}
	}
	return py_alerts;
}

static int py_srvsvc_NetSrvInfo403_set_alerts(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->alerts = NULL;
	} else {
		object->alerts = NULL;
		if (PyUnicode_Check(value)) {
			object->alerts = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->alerts = 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_srvsvc_NetSrvInfo403_get_security(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_security;
	py_security = PyInt_FromLong(object->security);
	return py_security;
}

static int py_srvsvc_NetSrvInfo403_set_security(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->security = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_numadmin(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_numadmin;
	py_numadmin = PyInt_FromLong(object->numadmin);
	return py_numadmin;
}

static int py_srvsvc_NetSrvInfo403_set_numadmin(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numadmin = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_lanmask(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_lanmask;
	py_lanmask = PyInt_FromLong(object->lanmask);
	return py_lanmask;
}

static int py_srvsvc_NetSrvInfo403_set_lanmask(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->lanmask = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_guestaccount(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_guestaccount;
	if (object->guestaccount == NULL) {
		py_guestaccount = Py_None;
		Py_INCREF(py_guestaccount);
	} else {
		if (object->guestaccount == NULL) {
			py_guestaccount = Py_None;
			Py_INCREF(py_guestaccount);
		} else {
			py_guestaccount = PyUnicode_Decode(object->guestaccount, strlen(object->guestaccount), "utf-8", "ignore");
		}
	}
	return py_guestaccount;
}

static int py_srvsvc_NetSrvInfo403_set_guestaccount(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->guestaccount = NULL;
	} else {
		object->guestaccount = NULL;
		if (PyUnicode_Check(value)) {
			object->guestaccount = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->guestaccount = 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_srvsvc_NetSrvInfo403_get_chdevs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_chdevs;
	py_chdevs = PyInt_FromLong(object->chdevs);
	return py_chdevs;
}

static int py_srvsvc_NetSrvInfo403_set_chdevs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->chdevs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_chdevqs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_chdevqs;
	py_chdevqs = PyInt_FromLong(object->chdevqs);
	return py_chdevqs;
}

static int py_srvsvc_NetSrvInfo403_set_chdevqs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->chdevqs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_chdevjobs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_chdevjobs;
	py_chdevjobs = PyInt_FromLong(object->chdevjobs);
	return py_chdevjobs;
}

static int py_srvsvc_NetSrvInfo403_set_chdevjobs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->chdevjobs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_connections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_connections;
	py_connections = PyInt_FromLong(object->connections);
	return py_connections;
}

static int py_srvsvc_NetSrvInfo403_set_connections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->connections = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_shares(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_shares;
	py_shares = PyInt_FromLong(object->shares);
	return py_shares;
}

static int py_srvsvc_NetSrvInfo403_set_shares(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->shares = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_openfiles(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_openfiles;
	py_openfiles = PyInt_FromLong(object->openfiles);
	return py_openfiles;
}

static int py_srvsvc_NetSrvInfo403_set_openfiles(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->openfiles = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_sessopen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_sessopen;
	py_sessopen = PyInt_FromLong(object->sessopen);
	return py_sessopen;
}

static int py_srvsvc_NetSrvInfo403_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessopen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_sesssvc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_sesssvc;
	py_sesssvc = PyInt_FromLong(object->sesssvc);
	return py_sesssvc;
}

static int py_srvsvc_NetSrvInfo403_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sesssvc = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_sessreqs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_sessreqs;
	py_sessreqs = PyInt_FromLong(object->sessreqs);
	return py_sessreqs;
}

static int py_srvsvc_NetSrvInfo403_set_sessreqs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessreqs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_opensearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_opensearch;
	py_opensearch = PyInt_FromLong(object->opensearch);
	return py_opensearch;
}

static int py_srvsvc_NetSrvInfo403_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->opensearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_activelocks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_activelocks;
	py_activelocks = PyInt_FromLong(object->activelocks);
	return py_activelocks;
}

static int py_srvsvc_NetSrvInfo403_set_activelocks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->activelocks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_numreqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_numreqbufs;
	py_numreqbufs = PyInt_FromLong(object->numreqbufs);
	return py_numreqbufs;
}

static int py_srvsvc_NetSrvInfo403_set_numreqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numreqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_sizereqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_sizereqbufs;
	py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
	return py_sizereqbufs;
}

static int py_srvsvc_NetSrvInfo403_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sizereqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_numbigbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_numbigbufs;
	py_numbigbufs = PyInt_FromLong(object->numbigbufs);
	return py_numbigbufs;
}

static int py_srvsvc_NetSrvInfo403_set_numbigbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numbigbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_numfiletasks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_numfiletasks;
	py_numfiletasks = PyInt_FromLong(object->numfiletasks);
	return py_numfiletasks;
}

static int py_srvsvc_NetSrvInfo403_set_numfiletasks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numfiletasks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_alertsched(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_alertsched;
	py_alertsched = PyInt_FromLong(object->alertsched);
	return py_alertsched;
}

static int py_srvsvc_NetSrvInfo403_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->alertsched = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_erroralert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_erroralert;
	py_erroralert = PyInt_FromLong(object->erroralert);
	return py_erroralert;
}

static int py_srvsvc_NetSrvInfo403_set_erroralert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->erroralert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_logonalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_logonalert;
	py_logonalert = PyInt_FromLong(object->logonalert);
	return py_logonalert;
}

static int py_srvsvc_NetSrvInfo403_set_logonalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->logonalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_accessalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_accessalert;
	py_accessalert = PyInt_FromLong(object->accessalert);
	return py_accessalert;
}

static int py_srvsvc_NetSrvInfo403_set_accessalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->accessalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_diskalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_diskalert;
	py_diskalert = PyInt_FromLong(object->diskalert);
	return py_diskalert;
}

static int py_srvsvc_NetSrvInfo403_set_diskalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->diskalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_netioalert(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_netioalert;
	py_netioalert = PyInt_FromLong(object->netioalert);
	return py_netioalert;
}

static int py_srvsvc_NetSrvInfo403_set_netioalert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->netioalert = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_maxaudits(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_maxaudits;
	py_maxaudits = PyInt_FromLong(object->maxaudits);
	return py_maxaudits;
}

static int py_srvsvc_NetSrvInfo403_set_maxaudits(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxaudits = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_srvheuristics(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_srvheuristics;
	if (object->srvheuristics == NULL) {
		py_srvheuristics = Py_None;
		Py_INCREF(py_srvheuristics);
	} else {
		if (object->srvheuristics == NULL) {
			py_srvheuristics = Py_None;
			Py_INCREF(py_srvheuristics);
		} else {
			py_srvheuristics = PyUnicode_Decode(object->srvheuristics, strlen(object->srvheuristics), "utf-8", "ignore");
		}
	}
	return py_srvheuristics;
}

static int py_srvsvc_NetSrvInfo403_set_srvheuristics(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->srvheuristics = NULL;
	} else {
		object->srvheuristics = NULL;
		if (PyUnicode_Check(value)) {
			object->srvheuristics = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->srvheuristics = 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_srvsvc_NetSrvInfo403_get_auditedevents(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_auditedevents;
	py_auditedevents = PyInt_FromLong(object->auditedevents);
	return py_auditedevents;
}

static int py_srvsvc_NetSrvInfo403_set_auditedevents(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->auditedevents = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_auditprofile(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_auditprofile;
	py_auditprofile = PyInt_FromLong(object->auditprofile);
	return py_auditprofile;
}

static int py_srvsvc_NetSrvInfo403_set_auditprofile(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->auditprofile = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo403_get_autopath(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
	PyObject *py_autopath;
	if (object->autopath == NULL) {
		py_autopath = Py_None;
		Py_INCREF(py_autopath);
	} else {
		if (object->autopath == NULL) {
			py_autopath = Py_None;
			Py_INCREF(py_autopath);
		} else {
			py_autopath = PyUnicode_Decode(object->autopath, strlen(object->autopath), "utf-8", "ignore");
		}
	}
	return py_autopath;
}

static int py_srvsvc_NetSrvInfo403_set_autopath(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->autopath = NULL;
	} else {
		object->autopath = NULL;
		if (PyUnicode_Check(value)) {
			object->autopath = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->autopath = 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_srvsvc_NetSrvInfo403_getsetters[] = {
	{ discard_const_p(char, "ulist_mtime"), py_srvsvc_NetSrvInfo403_get_ulist_mtime, py_srvsvc_NetSrvInfo403_set_ulist_mtime },
	{ discard_const_p(char, "glist_mtime"), py_srvsvc_NetSrvInfo403_get_glist_mtime, py_srvsvc_NetSrvInfo403_set_glist_mtime },
	{ discard_const_p(char, "alist_mtime"), py_srvsvc_NetSrvInfo403_get_alist_mtime, py_srvsvc_NetSrvInfo403_set_alist_mtime },
	{ discard_const_p(char, "alerts"), py_srvsvc_NetSrvInfo403_get_alerts, py_srvsvc_NetSrvInfo403_set_alerts },
	{ discard_const_p(char, "security"), py_srvsvc_NetSrvInfo403_get_security, py_srvsvc_NetSrvInfo403_set_security },
	{ discard_const_p(char, "numadmin"), py_srvsvc_NetSrvInfo403_get_numadmin, py_srvsvc_NetSrvInfo403_set_numadmin },
	{ discard_const_p(char, "lanmask"), py_srvsvc_NetSrvInfo403_get_lanmask, py_srvsvc_NetSrvInfo403_set_lanmask },
	{ discard_const_p(char, "guestaccount"), py_srvsvc_NetSrvInfo403_get_guestaccount, py_srvsvc_NetSrvInfo403_set_guestaccount },
	{ discard_const_p(char, "chdevs"), py_srvsvc_NetSrvInfo403_get_chdevs, py_srvsvc_NetSrvInfo403_set_chdevs },
	{ discard_const_p(char, "chdevqs"), py_srvsvc_NetSrvInfo403_get_chdevqs, py_srvsvc_NetSrvInfo403_set_chdevqs },
	{ discard_const_p(char, "chdevjobs"), py_srvsvc_NetSrvInfo403_get_chdevjobs, py_srvsvc_NetSrvInfo403_set_chdevjobs },
	{ discard_const_p(char, "connections"), py_srvsvc_NetSrvInfo403_get_connections, py_srvsvc_NetSrvInfo403_set_connections },
	{ discard_const_p(char, "shares"), py_srvsvc_NetSrvInfo403_get_shares, py_srvsvc_NetSrvInfo403_set_shares },
	{ discard_const_p(char, "openfiles"), py_srvsvc_NetSrvInfo403_get_openfiles, py_srvsvc_NetSrvInfo403_set_openfiles },
	{ discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo403_get_sessopen, py_srvsvc_NetSrvInfo403_set_sessopen },
	{ discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo403_get_sesssvc, py_srvsvc_NetSrvInfo403_set_sesssvc },
	{ discard_const_p(char, "sessreqs"), py_srvsvc_NetSrvInfo403_get_sessreqs, py_srvsvc_NetSrvInfo403_set_sessreqs },
	{ discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo403_get_opensearch, py_srvsvc_NetSrvInfo403_set_opensearch },
	{ discard_const_p(char, "activelocks"), py_srvsvc_NetSrvInfo403_get_activelocks, py_srvsvc_NetSrvInfo403_set_activelocks },
	{ discard_const_p(char, "numreqbufs"), py_srvsvc_NetSrvInfo403_get_numreqbufs, py_srvsvc_NetSrvInfo403_set_numreqbufs },
	{ discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo403_get_sizereqbufs, py_srvsvc_NetSrvInfo403_set_sizereqbufs },
	{ discard_const_p(char, "numbigbufs"), py_srvsvc_NetSrvInfo403_get_numbigbufs, py_srvsvc_NetSrvInfo403_set_numbigbufs },
	{ discard_const_p(char, "numfiletasks"), py_srvsvc_NetSrvInfo403_get_numfiletasks, py_srvsvc_NetSrvInfo403_set_numfiletasks },
	{ discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo403_get_alertsched, py_srvsvc_NetSrvInfo403_set_alertsched },
	{ discard_const_p(char, "erroralert"), py_srvsvc_NetSrvInfo403_get_erroralert, py_srvsvc_NetSrvInfo403_set_erroralert },
	{ discard_const_p(char, "logonalert"), py_srvsvc_NetSrvInfo403_get_logonalert, py_srvsvc_NetSrvInfo403_set_logonalert },
	{ discard_const_p(char, "accessalert"), py_srvsvc_NetSrvInfo403_get_accessalert, py_srvsvc_NetSrvInfo403_set_accessalert },
	{ discard_const_p(char, "diskalert"), py_srvsvc_NetSrvInfo403_get_diskalert, py_srvsvc_NetSrvInfo403_set_diskalert },
	{ discard_const_p(char, "netioalert"), py_srvsvc_NetSrvInfo403_get_netioalert, py_srvsvc_NetSrvInfo403_set_netioalert },
	{ discard_const_p(char, "maxaudits"), py_srvsvc_NetSrvInfo403_get_maxaudits, py_srvsvc_NetSrvInfo403_set_maxaudits },
	{ discard_const_p(char, "srvheuristics"), py_srvsvc_NetSrvInfo403_get_srvheuristics, py_srvsvc_NetSrvInfo403_set_srvheuristics },
	{ discard_const_p(char, "auditedevents"), py_srvsvc_NetSrvInfo403_get_auditedevents, py_srvsvc_NetSrvInfo403_set_auditedevents },
	{ discard_const_p(char, "auditprofile"), py_srvsvc_NetSrvInfo403_get_auditprofile, py_srvsvc_NetSrvInfo403_set_auditprofile },
	{ discard_const_p(char, "autopath"), py_srvsvc_NetSrvInfo403_get_autopath, py_srvsvc_NetSrvInfo403_set_autopath },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo403_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo403, type);
}


static PyTypeObject srvsvc_NetSrvInfo403_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo403",
	.tp_getset = py_srvsvc_NetSrvInfo403_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo403_new,
};


static PyObject *py_srvsvc_NetSrvInfo502_get_sessopen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_sessopen;
	py_sessopen = PyInt_FromLong(object->sessopen);
	return py_sessopen;
}

static int py_srvsvc_NetSrvInfo502_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessopen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_sesssvc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_sesssvc;
	py_sesssvc = PyInt_FromLong(object->sesssvc);
	return py_sesssvc;
}

static int py_srvsvc_NetSrvInfo502_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sesssvc = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_opensearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_opensearch;
	py_opensearch = PyInt_FromLong(object->opensearch);
	return py_opensearch;
}

static int py_srvsvc_NetSrvInfo502_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->opensearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_sizereqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_sizereqbufs;
	py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
	return py_sizereqbufs;
}

static int py_srvsvc_NetSrvInfo502_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sizereqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_initworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_initworkitems;
	py_initworkitems = PyInt_FromLong(object->initworkitems);
	return py_initworkitems;
}

static int py_srvsvc_NetSrvInfo502_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_maxworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_maxworkitems;
	py_maxworkitems = PyInt_FromLong(object->maxworkitems);
	return py_maxworkitems;
}

static int py_srvsvc_NetSrvInfo502_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_rawworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_rawworkitems;
	py_rawworkitems = PyInt_FromLong(object->rawworkitems);
	return py_rawworkitems;
}

static int py_srvsvc_NetSrvInfo502_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->rawworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_irpstacksize(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_irpstacksize;
	py_irpstacksize = PyInt_FromLong(object->irpstacksize);
	return py_irpstacksize;
}

static int py_srvsvc_NetSrvInfo502_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->irpstacksize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_maxrawbuflen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_maxrawbuflen;
	py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
	return py_maxrawbuflen;
}

static int py_srvsvc_NetSrvInfo502_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxrawbuflen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_sessusers(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_sessusers;
	py_sessusers = PyInt_FromLong(object->sessusers);
	return py_sessusers;
}

static int py_srvsvc_NetSrvInfo502_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessusers = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_sessconns(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_sessconns;
	py_sessconns = PyInt_FromLong(object->sessconns);
	return py_sessconns;
}

static int py_srvsvc_NetSrvInfo502_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessconns = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_maxpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_maxpagedmemoryusage;
	py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
	return py_maxpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo502_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_maxnonpagedmemoryusage;
	py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
	return py_maxnonpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo502_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxnonpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_enablesoftcompat(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesoftcompat;
	py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
	return py_enablesoftcompat;
}

static int py_srvsvc_NetSrvInfo502_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesoftcompat = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_enableforcedlogoff(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_enableforcedlogoff;
	py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
	return py_enableforcedlogoff;
}

static int py_srvsvc_NetSrvInfo502_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableforcedlogoff = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_timesource(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_timesource;
	py_timesource = PyInt_FromLong(object->timesource);
	return py_timesource;
}

static int py_srvsvc_NetSrvInfo502_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timesource = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_acceptdownlevelapis(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_acceptdownlevelapis;
	py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
	return py_acceptdownlevelapis;
}

static int py_srvsvc_NetSrvInfo502_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->acceptdownlevelapis = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo502_get_lmannounce(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_lmannounce;
	py_lmannounce = PyInt_FromLong(object->lmannounce);
	return py_lmannounce;
}

static int py_srvsvc_NetSrvInfo502_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->lmannounce = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo502_getsetters[] = {
	{ discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo502_get_sessopen, py_srvsvc_NetSrvInfo502_set_sessopen },
	{ discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo502_get_sesssvc, py_srvsvc_NetSrvInfo502_set_sesssvc },
	{ discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo502_get_opensearch, py_srvsvc_NetSrvInfo502_set_opensearch },
	{ discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo502_get_sizereqbufs, py_srvsvc_NetSrvInfo502_set_sizereqbufs },
	{ discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo502_get_initworkitems, py_srvsvc_NetSrvInfo502_set_initworkitems },
	{ discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo502_get_maxworkitems, py_srvsvc_NetSrvInfo502_set_maxworkitems },
	{ discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo502_get_rawworkitems, py_srvsvc_NetSrvInfo502_set_rawworkitems },
	{ discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo502_get_irpstacksize, py_srvsvc_NetSrvInfo502_set_irpstacksize },
	{ discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo502_get_maxrawbuflen, py_srvsvc_NetSrvInfo502_set_maxrawbuflen },
	{ discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo502_get_sessusers, py_srvsvc_NetSrvInfo502_set_sessusers },
	{ discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo502_get_sessconns, py_srvsvc_NetSrvInfo502_set_sessconns },
	{ discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo502_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo502_set_maxpagedmemoryusage },
	{ discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo502_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo502_set_maxnonpagedmemoryusage },
	{ discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo502_get_enablesoftcompat, py_srvsvc_NetSrvInfo502_set_enablesoftcompat },
	{ discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo502_get_enableforcedlogoff, py_srvsvc_NetSrvInfo502_set_enableforcedlogoff },
	{ discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo502_get_timesource, py_srvsvc_NetSrvInfo502_set_timesource },
	{ discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo502_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo502_set_acceptdownlevelapis },
	{ discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo502_get_lmannounce, py_srvsvc_NetSrvInfo502_set_lmannounce },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo502, type);
}


static PyTypeObject srvsvc_NetSrvInfo502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo502",
	.tp_getset = py_srvsvc_NetSrvInfo502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo502_new,
};


static PyObject *py_srvsvc_NetSrvInfo503_get_sessopen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_sessopen;
	py_sessopen = PyInt_FromLong(object->sessopen);
	return py_sessopen;
}

static int py_srvsvc_NetSrvInfo503_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessopen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_sesssvc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_sesssvc;
	py_sesssvc = PyInt_FromLong(object->sesssvc);
	return py_sesssvc;
}

static int py_srvsvc_NetSrvInfo503_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sesssvc = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_opensearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_opensearch;
	py_opensearch = PyInt_FromLong(object->opensearch);
	return py_opensearch;
}

static int py_srvsvc_NetSrvInfo503_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->opensearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_sizereqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_sizereqbufs;
	py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
	return py_sizereqbufs;
}

static int py_srvsvc_NetSrvInfo503_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sizereqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_initworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_initworkitems;
	py_initworkitems = PyInt_FromLong(object->initworkitems);
	return py_initworkitems;
}

static int py_srvsvc_NetSrvInfo503_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxworkitems;
	py_maxworkitems = PyInt_FromLong(object->maxworkitems);
	return py_maxworkitems;
}

static int py_srvsvc_NetSrvInfo503_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_rawworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_rawworkitems;
	py_rawworkitems = PyInt_FromLong(object->rawworkitems);
	return py_rawworkitems;
}

static int py_srvsvc_NetSrvInfo503_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->rawworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_irpstacksize(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_irpstacksize;
	py_irpstacksize = PyInt_FromLong(object->irpstacksize);
	return py_irpstacksize;
}

static int py_srvsvc_NetSrvInfo503_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->irpstacksize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxrawbuflen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxrawbuflen;
	py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
	return py_maxrawbuflen;
}

static int py_srvsvc_NetSrvInfo503_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxrawbuflen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_sessusers(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_sessusers;
	py_sessusers = PyInt_FromLong(object->sessusers);
	return py_sessusers;
}

static int py_srvsvc_NetSrvInfo503_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessusers = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_sessconns(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_sessconns;
	py_sessconns = PyInt_FromLong(object->sessconns);
	return py_sessconns;
}

static int py_srvsvc_NetSrvInfo503_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessconns = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxpagedmemoryusage;
	py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
	return py_maxpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo503_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxnonpagedmemoryusage;
	py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
	return py_maxnonpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo503_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxnonpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enablesoftcompat(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesoftcompat;
	py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
	return py_enablesoftcompat;
}

static int py_srvsvc_NetSrvInfo503_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesoftcompat = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enableforcedlogoff(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enableforcedlogoff;
	py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
	return py_enableforcedlogoff;
}

static int py_srvsvc_NetSrvInfo503_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableforcedlogoff = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_timesource(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_timesource;
	py_timesource = PyInt_FromLong(object->timesource);
	return py_timesource;
}

static int py_srvsvc_NetSrvInfo503_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timesource = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_acceptdownlevelapis(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_acceptdownlevelapis;
	py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
	return py_acceptdownlevelapis;
}

static int py_srvsvc_NetSrvInfo503_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->acceptdownlevelapis = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_lmannounce(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_lmannounce;
	py_lmannounce = PyInt_FromLong(object->lmannounce);
	return py_lmannounce;
}

static int py_srvsvc_NetSrvInfo503_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->lmannounce = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_domain(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_domain;
	if (object->domain == NULL) {
		py_domain = Py_None;
		Py_INCREF(py_domain);
	} else {
		if (object->domain == NULL) {
			py_domain = Py_None;
			Py_INCREF(py_domain);
		} else {
			py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
		}
	}
	return py_domain;
}

static int py_srvsvc_NetSrvInfo503_set_domain(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->domain = NULL;
	} else {
		object->domain = NULL;
		if (PyUnicode_Check(value)) {
			object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->domain = 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_srvsvc_NetSrvInfo503_get_maxcopyreadlen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxcopyreadlen;
	py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
	return py_maxcopyreadlen;
}

static int py_srvsvc_NetSrvInfo503_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxcopyreadlen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxcopywritelen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxcopywritelen;
	py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
	return py_maxcopywritelen;
}

static int py_srvsvc_NetSrvInfo503_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxcopywritelen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_minkeepsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_minkeepsearch;
	py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
	return py_minkeepsearch;
}

static int py_srvsvc_NetSrvInfo503_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minkeepsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxkeepsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxkeepsearch;
	py_maxkeepsearch = PyInt_FromLong(object->maxkeepsearch);
	return py_maxkeepsearch;
}

static int py_srvsvc_NetSrvInfo503_set_maxkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxkeepsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_minkeepcomplsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_minkeepcomplsearch;
	py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
	return py_minkeepcomplsearch;
}

static int py_srvsvc_NetSrvInfo503_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minkeepcomplsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxkeepcomplsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxkeepcomplsearch;
	py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
	return py_maxkeepcomplsearch;
}

static int py_srvsvc_NetSrvInfo503_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxkeepcomplsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_threadcountadd(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_threadcountadd;
	py_threadcountadd = PyInt_FromLong(object->threadcountadd);
	return py_threadcountadd;
}

static int py_srvsvc_NetSrvInfo503_set_threadcountadd(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->threadcountadd = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_numlockthreads(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_numlockthreads;
	py_numlockthreads = PyInt_FromLong(object->numlockthreads);
	return py_numlockthreads;
}

static int py_srvsvc_NetSrvInfo503_set_numlockthreads(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numlockthreads = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_scavtimeout(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_scavtimeout;
	py_scavtimeout = PyInt_FromLong(object->scavtimeout);
	return py_scavtimeout;
}

static int py_srvsvc_NetSrvInfo503_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->scavtimeout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_minrcvqueue(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_minrcvqueue;
	py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
	return py_minrcvqueue;
}

static int py_srvsvc_NetSrvInfo503_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minrcvqueue = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_minfreeworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_minfreeworkitems;
	py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
	return py_minfreeworkitems;
}

static int py_srvsvc_NetSrvInfo503_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minfreeworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_xactmemsize(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_xactmemsize;
	py_xactmemsize = PyInt_FromLong(object->xactmemsize);
	return py_xactmemsize;
}

static int py_srvsvc_NetSrvInfo503_set_xactmemsize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->xactmemsize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_threadpriority(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_threadpriority;
	py_threadpriority = PyInt_FromLong(object->threadpriority);
	return py_threadpriority;
}

static int py_srvsvc_NetSrvInfo503_set_threadpriority(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->threadpriority = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxmpxct(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxmpxct;
	py_maxmpxct = PyInt_FromLong(object->maxmpxct);
	return py_maxmpxct;
}

static int py_srvsvc_NetSrvInfo503_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxmpxct = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_oplockbreakwait(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_oplockbreakwait;
	py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
	return py_oplockbreakwait;
}

static int py_srvsvc_NetSrvInfo503_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->oplockbreakwait = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_oplockbreakresponsewait(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_oplockbreakresponsewait;
	py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
	return py_oplockbreakresponsewait;
}

static int py_srvsvc_NetSrvInfo503_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->oplockbreakresponsewait = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enableoplocks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enableoplocks;
	py_enableoplocks = PyInt_FromLong(object->enableoplocks);
	return py_enableoplocks;
}

static int py_srvsvc_NetSrvInfo503_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableoplocks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enableoplockforceclose(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enableoplockforceclose;
	py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
	return py_enableoplockforceclose;
}

static int py_srvsvc_NetSrvInfo503_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableoplockforceclose = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enablefcbopens(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enablefcbopens;
	py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
	return py_enablefcbopens;
}

static int py_srvsvc_NetSrvInfo503_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablefcbopens = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enableraw(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enableraw;
	py_enableraw = PyInt_FromLong(object->enableraw);
	return py_enableraw;
}

static int py_srvsvc_NetSrvInfo503_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableraw = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_enablesharednetdrives(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesharednetdrives;
	py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
	return py_enablesharednetdrives;
}

static int py_srvsvc_NetSrvInfo503_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesharednetdrives = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_minfreeconnections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_minfreeconnections;
	py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
	return py_minfreeconnections;
}

static int py_srvsvc_NetSrvInfo503_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minfreeconnections = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo503_get_maxfreeconnections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
	PyObject *py_maxfreeconnections;
	py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
	return py_maxfreeconnections;
}

static int py_srvsvc_NetSrvInfo503_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxfreeconnections = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo503_getsetters[] = {
	{ discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo503_get_sessopen, py_srvsvc_NetSrvInfo503_set_sessopen },
	{ discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo503_get_sesssvc, py_srvsvc_NetSrvInfo503_set_sesssvc },
	{ discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo503_get_opensearch, py_srvsvc_NetSrvInfo503_set_opensearch },
	{ discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo503_get_sizereqbufs, py_srvsvc_NetSrvInfo503_set_sizereqbufs },
	{ discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo503_get_initworkitems, py_srvsvc_NetSrvInfo503_set_initworkitems },
	{ discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo503_get_maxworkitems, py_srvsvc_NetSrvInfo503_set_maxworkitems },
	{ discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo503_get_rawworkitems, py_srvsvc_NetSrvInfo503_set_rawworkitems },
	{ discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo503_get_irpstacksize, py_srvsvc_NetSrvInfo503_set_irpstacksize },
	{ discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo503_get_maxrawbuflen, py_srvsvc_NetSrvInfo503_set_maxrawbuflen },
	{ discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo503_get_sessusers, py_srvsvc_NetSrvInfo503_set_sessusers },
	{ discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo503_get_sessconns, py_srvsvc_NetSrvInfo503_set_sessconns },
	{ discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo503_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo503_set_maxpagedmemoryusage },
	{ discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo503_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo503_set_maxnonpagedmemoryusage },
	{ discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo503_get_enablesoftcompat, py_srvsvc_NetSrvInfo503_set_enablesoftcompat },
	{ discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo503_get_enableforcedlogoff, py_srvsvc_NetSrvInfo503_set_enableforcedlogoff },
	{ discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo503_get_timesource, py_srvsvc_NetSrvInfo503_set_timesource },
	{ discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo503_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo503_set_acceptdownlevelapis },
	{ discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo503_get_lmannounce, py_srvsvc_NetSrvInfo503_set_lmannounce },
	{ discard_const_p(char, "domain"), py_srvsvc_NetSrvInfo503_get_domain, py_srvsvc_NetSrvInfo503_set_domain },
	{ discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo503_get_maxcopyreadlen, py_srvsvc_NetSrvInfo503_set_maxcopyreadlen },
	{ discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo503_get_maxcopywritelen, py_srvsvc_NetSrvInfo503_set_maxcopywritelen },
	{ discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo503_get_minkeepsearch, py_srvsvc_NetSrvInfo503_set_minkeepsearch },
	{ discard_const_p(char, "maxkeepsearch"), py_srvsvc_NetSrvInfo503_get_maxkeepsearch, py_srvsvc_NetSrvInfo503_set_maxkeepsearch },
	{ discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo503_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo503_set_minkeepcomplsearch },
	{ discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo503_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo503_set_maxkeepcomplsearch },
	{ discard_const_p(char, "threadcountadd"), py_srvsvc_NetSrvInfo503_get_threadcountadd, py_srvsvc_NetSrvInfo503_set_threadcountadd },
	{ discard_const_p(char, "numlockthreads"), py_srvsvc_NetSrvInfo503_get_numlockthreads, py_srvsvc_NetSrvInfo503_set_numlockthreads },
	{ discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo503_get_scavtimeout, py_srvsvc_NetSrvInfo503_set_scavtimeout },
	{ discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo503_get_minrcvqueue, py_srvsvc_NetSrvInfo503_set_minrcvqueue },
	{ discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo503_get_minfreeworkitems, py_srvsvc_NetSrvInfo503_set_minfreeworkitems },
	{ discard_const_p(char, "xactmemsize"), py_srvsvc_NetSrvInfo503_get_xactmemsize, py_srvsvc_NetSrvInfo503_set_xactmemsize },
	{ discard_const_p(char, "threadpriority"), py_srvsvc_NetSrvInfo503_get_threadpriority, py_srvsvc_NetSrvInfo503_set_threadpriority },
	{ discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo503_get_maxmpxct, py_srvsvc_NetSrvInfo503_set_maxmpxct },
	{ discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo503_get_oplockbreakwait, py_srvsvc_NetSrvInfo503_set_oplockbreakwait },
	{ discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo503_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo503_set_oplockbreakresponsewait },
	{ discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo503_get_enableoplocks, py_srvsvc_NetSrvInfo503_set_enableoplocks },
	{ discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo503_get_enableoplockforceclose, py_srvsvc_NetSrvInfo503_set_enableoplockforceclose },
	{ discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo503_get_enablefcbopens, py_srvsvc_NetSrvInfo503_set_enablefcbopens },
	{ discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo503_get_enableraw, py_srvsvc_NetSrvInfo503_set_enableraw },
	{ discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo503_get_enablesharednetdrives, py_srvsvc_NetSrvInfo503_set_enablesharednetdrives },
	{ discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo503_get_minfreeconnections, py_srvsvc_NetSrvInfo503_set_minfreeconnections },
	{ discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo503_get_maxfreeconnections, py_srvsvc_NetSrvInfo503_set_maxfreeconnections },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo503_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo503, type);
}


static PyTypeObject srvsvc_NetSrvInfo503_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo503",
	.tp_getset = py_srvsvc_NetSrvInfo503_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo503_new,
};


static PyObject *py_srvsvc_NetSrvInfo599_get_sessopen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_sessopen;
	py_sessopen = PyInt_FromLong(object->sessopen);
	return py_sessopen;
}

static int py_srvsvc_NetSrvInfo599_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessopen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_sesssvc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_sesssvc;
	py_sesssvc = PyInt_FromLong(object->sesssvc);
	return py_sesssvc;
}

static int py_srvsvc_NetSrvInfo599_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sesssvc = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_opensearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_opensearch;
	py_opensearch = PyInt_FromLong(object->opensearch);
	return py_opensearch;
}

static int py_srvsvc_NetSrvInfo599_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->opensearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_sizereqbufs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_sizereqbufs;
	py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
	return py_sizereqbufs;
}

static int py_srvsvc_NetSrvInfo599_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sizereqbufs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_initworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_initworkitems;
	py_initworkitems = PyInt_FromLong(object->initworkitems);
	return py_initworkitems;
}

static int py_srvsvc_NetSrvInfo599_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxworkitems;
	py_maxworkitems = PyInt_FromLong(object->maxworkitems);
	return py_maxworkitems;
}

static int py_srvsvc_NetSrvInfo599_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_rawworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_rawworkitems;
	py_rawworkitems = PyInt_FromLong(object->rawworkitems);
	return py_rawworkitems;
}

static int py_srvsvc_NetSrvInfo599_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->rawworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_irpstacksize(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_irpstacksize;
	py_irpstacksize = PyInt_FromLong(object->irpstacksize);
	return py_irpstacksize;
}

static int py_srvsvc_NetSrvInfo599_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->irpstacksize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxrawbuflen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxrawbuflen;
	py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
	return py_maxrawbuflen;
}

static int py_srvsvc_NetSrvInfo599_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxrawbuflen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_sessusers(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_sessusers;
	py_sessusers = PyInt_FromLong(object->sessusers);
	return py_sessusers;
}

static int py_srvsvc_NetSrvInfo599_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessusers = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_sessconns(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_sessconns;
	py_sessconns = PyInt_FromLong(object->sessconns);
	return py_sessconns;
}

static int py_srvsvc_NetSrvInfo599_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessconns = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxpagedmemoryusage;
	py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
	return py_maxpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo599_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxnonpagedmemoryusage;
	py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
	return py_maxnonpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo599_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxnonpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enablesoftcompat(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesoftcompat;
	py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
	return py_enablesoftcompat;
}

static int py_srvsvc_NetSrvInfo599_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesoftcompat = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enableforcedlogoff(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enableforcedlogoff;
	py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
	return py_enableforcedlogoff;
}

static int py_srvsvc_NetSrvInfo599_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableforcedlogoff = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_timesource(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_timesource;
	py_timesource = PyInt_FromLong(object->timesource);
	return py_timesource;
}

static int py_srvsvc_NetSrvInfo599_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timesource = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_acceptdownlevelapis(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_acceptdownlevelapis;
	py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
	return py_acceptdownlevelapis;
}

static int py_srvsvc_NetSrvInfo599_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->acceptdownlevelapis = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_lmannounce(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_lmannounce;
	py_lmannounce = PyInt_FromLong(object->lmannounce);
	return py_lmannounce;
}

static int py_srvsvc_NetSrvInfo599_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->lmannounce = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_domain(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_domain;
	if (object->domain == NULL) {
		py_domain = Py_None;
		Py_INCREF(py_domain);
	} else {
		if (object->domain == NULL) {
			py_domain = Py_None;
			Py_INCREF(py_domain);
		} else {
			py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
		}
	}
	return py_domain;
}

static int py_srvsvc_NetSrvInfo599_set_domain(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->domain = NULL;
	} else {
		object->domain = NULL;
		if (PyUnicode_Check(value)) {
			object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->domain = 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_srvsvc_NetSrvInfo599_get_maxcopyreadlen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxcopyreadlen;
	py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
	return py_maxcopyreadlen;
}

static int py_srvsvc_NetSrvInfo599_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxcopyreadlen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxcopywritelen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxcopywritelen;
	py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
	return py_maxcopywritelen;
}

static int py_srvsvc_NetSrvInfo599_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxcopywritelen = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_minkeepsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_minkeepsearch;
	py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
	return py_minkeepsearch;
}

static int py_srvsvc_NetSrvInfo599_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minkeepsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_minkeepcomplsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_minkeepcomplsearch;
	py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
	return py_minkeepcomplsearch;
}

static int py_srvsvc_NetSrvInfo599_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minkeepcomplsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxkeepcomplsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxkeepcomplsearch;
	py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
	return py_maxkeepcomplsearch;
}

static int py_srvsvc_NetSrvInfo599_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxkeepcomplsearch = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_threadcountadd(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_threadcountadd;
	py_threadcountadd = PyInt_FromLong(object->threadcountadd);
	return py_threadcountadd;
}

static int py_srvsvc_NetSrvInfo599_set_threadcountadd(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->threadcountadd = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_numlockthreads(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_numlockthreads;
	py_numlockthreads = PyInt_FromLong(object->numlockthreads);
	return py_numlockthreads;
}

static int py_srvsvc_NetSrvInfo599_set_numlockthreads(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->numlockthreads = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_scavtimeout(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_scavtimeout;
	py_scavtimeout = PyInt_FromLong(object->scavtimeout);
	return py_scavtimeout;
}

static int py_srvsvc_NetSrvInfo599_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->scavtimeout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_minrcvqueue(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_minrcvqueue;
	py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
	return py_minrcvqueue;
}

static int py_srvsvc_NetSrvInfo599_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minrcvqueue = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_minfreeworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_minfreeworkitems;
	py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
	return py_minfreeworkitems;
}

static int py_srvsvc_NetSrvInfo599_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minfreeworkitems = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_xactmemsize(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_xactmemsize;
	py_xactmemsize = PyInt_FromLong(object->xactmemsize);
	return py_xactmemsize;
}

static int py_srvsvc_NetSrvInfo599_set_xactmemsize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->xactmemsize = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_threadpriority(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_threadpriority;
	py_threadpriority = PyInt_FromLong(object->threadpriority);
	return py_threadpriority;
}

static int py_srvsvc_NetSrvInfo599_set_threadpriority(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->threadpriority = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxmpxct(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxmpxct;
	py_maxmpxct = PyInt_FromLong(object->maxmpxct);
	return py_maxmpxct;
}

static int py_srvsvc_NetSrvInfo599_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxmpxct = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_oplockbreakwait(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_oplockbreakwait;
	py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
	return py_oplockbreakwait;
}

static int py_srvsvc_NetSrvInfo599_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->oplockbreakwait = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_oplockbreakresponsewait(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_oplockbreakresponsewait;
	py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
	return py_oplockbreakresponsewait;
}

static int py_srvsvc_NetSrvInfo599_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->oplockbreakresponsewait = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enableoplocks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enableoplocks;
	py_enableoplocks = PyInt_FromLong(object->enableoplocks);
	return py_enableoplocks;
}

static int py_srvsvc_NetSrvInfo599_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableoplocks = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enableoplockforceclose(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enableoplockforceclose;
	py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
	return py_enableoplockforceclose;
}

static int py_srvsvc_NetSrvInfo599_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableoplockforceclose = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enablefcbopens(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enablefcbopens;
	py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
	return py_enablefcbopens;
}

static int py_srvsvc_NetSrvInfo599_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablefcbopens = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enableraw(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enableraw;
	py_enableraw = PyInt_FromLong(object->enableraw);
	return py_enableraw;
}

static int py_srvsvc_NetSrvInfo599_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableraw = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_enablesharednetdrives(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesharednetdrives;
	py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
	return py_enablesharednetdrives;
}

static int py_srvsvc_NetSrvInfo599_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesharednetdrives = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_minfreeconnections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_minfreeconnections;
	py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
	return py_minfreeconnections;
}

static int py_srvsvc_NetSrvInfo599_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minfreeconnections = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxfreeconnections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxfreeconnections;
	py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
	return py_maxfreeconnections;
}

static int py_srvsvc_NetSrvInfo599_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxfreeconnections = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_initsesstable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_initsesstable;
	py_initsesstable = PyInt_FromLong(object->initsesstable);
	return py_initsesstable;
}

static int py_srvsvc_NetSrvInfo599_set_initsesstable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initsesstable = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_initconntable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_initconntable;
	py_initconntable = PyInt_FromLong(object->initconntable);
	return py_initconntable;
}

static int py_srvsvc_NetSrvInfo599_set_initconntable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initconntable = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_initfiletable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_initfiletable;
	py_initfiletable = PyInt_FromLong(object->initfiletable);
	return py_initfiletable;
}

static int py_srvsvc_NetSrvInfo599_set_initfiletable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initfiletable = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_initsearchtable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_initsearchtable;
	py_initsearchtable = PyInt_FromLong(object->initsearchtable);
	return py_initsearchtable;
}

static int py_srvsvc_NetSrvInfo599_set_initsearchtable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initsearchtable = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_alertsched(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_alertsched;
	py_alertsched = PyInt_FromLong(object->alertsched);
	return py_alertsched;
}

static int py_srvsvc_NetSrvInfo599_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->alertsched = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_errortreshold(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_errortreshold;
	py_errortreshold = PyInt_FromLong(object->errortreshold);
	return py_errortreshold;
}

static int py_srvsvc_NetSrvInfo599_set_errortreshold(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->errortreshold = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_networkerrortreshold(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_networkerrortreshold;
	py_networkerrortreshold = PyInt_FromLong(object->networkerrortreshold);
	return py_networkerrortreshold;
}

static int py_srvsvc_NetSrvInfo599_set_networkerrortreshold(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->networkerrortreshold = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_diskspacetreshold(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_diskspacetreshold;
	py_diskspacetreshold = PyInt_FromLong(object->diskspacetreshold);
	return py_diskspacetreshold;
}

static int py_srvsvc_NetSrvInfo599_set_diskspacetreshold(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->diskspacetreshold = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_reserved(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_reserved;
	py_reserved = PyInt_FromLong(object->reserved);
	return py_reserved;
}

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

static PyObject *py_srvsvc_NetSrvInfo599_get_maxlinkdelay(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxlinkdelay;
	py_maxlinkdelay = PyInt_FromLong(object->maxlinkdelay);
	return py_maxlinkdelay;
}

static int py_srvsvc_NetSrvInfo599_set_maxlinkdelay(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxlinkdelay = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_minlinkthroughput(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_minlinkthroughput;
	py_minlinkthroughput = PyInt_FromLong(object->minlinkthroughput);
	return py_minlinkthroughput;
}

static int py_srvsvc_NetSrvInfo599_set_minlinkthroughput(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minlinkthroughput = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_linkinfovalidtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_linkinfovalidtime;
	py_linkinfovalidtime = PyInt_FromLong(object->linkinfovalidtime);
	return py_linkinfovalidtime;
}

static int py_srvsvc_NetSrvInfo599_set_linkinfovalidtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->linkinfovalidtime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_scavqosinfoupdatetime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_scavqosinfoupdatetime;
	py_scavqosinfoupdatetime = PyInt_FromLong(object->scavqosinfoupdatetime);
	return py_scavqosinfoupdatetime;
}

static int py_srvsvc_NetSrvInfo599_set_scavqosinfoupdatetime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->scavqosinfoupdatetime = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetSrvInfo599_get_maxworkitemidletime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
	PyObject *py_maxworkitemidletime;
	py_maxworkitemidletime = PyInt_FromLong(object->maxworkitemidletime);
	return py_maxworkitemidletime;
}

static int py_srvsvc_NetSrvInfo599_set_maxworkitemidletime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxworkitemidletime = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo599_getsetters[] = {
	{ discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo599_get_sessopen, py_srvsvc_NetSrvInfo599_set_sessopen },
	{ discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo599_get_sesssvc, py_srvsvc_NetSrvInfo599_set_sesssvc },
	{ discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo599_get_opensearch, py_srvsvc_NetSrvInfo599_set_opensearch },
	{ discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo599_get_sizereqbufs, py_srvsvc_NetSrvInfo599_set_sizereqbufs },
	{ discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo599_get_initworkitems, py_srvsvc_NetSrvInfo599_set_initworkitems },
	{ discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo599_get_maxworkitems, py_srvsvc_NetSrvInfo599_set_maxworkitems },
	{ discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo599_get_rawworkitems, py_srvsvc_NetSrvInfo599_set_rawworkitems },
	{ discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo599_get_irpstacksize, py_srvsvc_NetSrvInfo599_set_irpstacksize },
	{ discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo599_get_maxrawbuflen, py_srvsvc_NetSrvInfo599_set_maxrawbuflen },
	{ discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo599_get_sessusers, py_srvsvc_NetSrvInfo599_set_sessusers },
	{ discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo599_get_sessconns, py_srvsvc_NetSrvInfo599_set_sessconns },
	{ discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo599_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo599_set_maxpagedmemoryusage },
	{ discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo599_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo599_set_maxnonpagedmemoryusage },
	{ discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo599_get_enablesoftcompat, py_srvsvc_NetSrvInfo599_set_enablesoftcompat },
	{ discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo599_get_enableforcedlogoff, py_srvsvc_NetSrvInfo599_set_enableforcedlogoff },
	{ discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo599_get_timesource, py_srvsvc_NetSrvInfo599_set_timesource },
	{ discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo599_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo599_set_acceptdownlevelapis },
	{ discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo599_get_lmannounce, py_srvsvc_NetSrvInfo599_set_lmannounce },
	{ discard_const_p(char, "domain"), py_srvsvc_NetSrvInfo599_get_domain, py_srvsvc_NetSrvInfo599_set_domain },
	{ discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo599_get_maxcopyreadlen, py_srvsvc_NetSrvInfo599_set_maxcopyreadlen },
	{ discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo599_get_maxcopywritelen, py_srvsvc_NetSrvInfo599_set_maxcopywritelen },
	{ discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo599_get_minkeepsearch, py_srvsvc_NetSrvInfo599_set_minkeepsearch },
	{ discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo599_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo599_set_minkeepcomplsearch },
	{ discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo599_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo599_set_maxkeepcomplsearch },
	{ discard_const_p(char, "threadcountadd"), py_srvsvc_NetSrvInfo599_get_threadcountadd, py_srvsvc_NetSrvInfo599_set_threadcountadd },
	{ discard_const_p(char, "numlockthreads"), py_srvsvc_NetSrvInfo599_get_numlockthreads, py_srvsvc_NetSrvInfo599_set_numlockthreads },
	{ discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo599_get_scavtimeout, py_srvsvc_NetSrvInfo599_set_scavtimeout },
	{ discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo599_get_minrcvqueue, py_srvsvc_NetSrvInfo599_set_minrcvqueue },
	{ discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo599_get_minfreeworkitems, py_srvsvc_NetSrvInfo599_set_minfreeworkitems },
	{ discard_const_p(char, "xactmemsize"), py_srvsvc_NetSrvInfo599_get_xactmemsize, py_srvsvc_NetSrvInfo599_set_xactmemsize },
	{ discard_const_p(char, "threadpriority"), py_srvsvc_NetSrvInfo599_get_threadpriority, py_srvsvc_NetSrvInfo599_set_threadpriority },
	{ discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo599_get_maxmpxct, py_srvsvc_NetSrvInfo599_set_maxmpxct },
	{ discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo599_get_oplockbreakwait, py_srvsvc_NetSrvInfo599_set_oplockbreakwait },
	{ discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo599_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo599_set_oplockbreakresponsewait },
	{ discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo599_get_enableoplocks, py_srvsvc_NetSrvInfo599_set_enableoplocks },
	{ discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo599_get_enableoplockforceclose, py_srvsvc_NetSrvInfo599_set_enableoplockforceclose },
	{ discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo599_get_enablefcbopens, py_srvsvc_NetSrvInfo599_set_enablefcbopens },
	{ discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo599_get_enableraw, py_srvsvc_NetSrvInfo599_set_enableraw },
	{ discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo599_get_enablesharednetdrives, py_srvsvc_NetSrvInfo599_set_enablesharednetdrives },
	{ discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo599_get_minfreeconnections, py_srvsvc_NetSrvInfo599_set_minfreeconnections },
	{ discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo599_get_maxfreeconnections, py_srvsvc_NetSrvInfo599_set_maxfreeconnections },
	{ discard_const_p(char, "initsesstable"), py_srvsvc_NetSrvInfo599_get_initsesstable, py_srvsvc_NetSrvInfo599_set_initsesstable },
	{ discard_const_p(char, "initconntable"), py_srvsvc_NetSrvInfo599_get_initconntable, py_srvsvc_NetSrvInfo599_set_initconntable },
	{ discard_const_p(char, "initfiletable"), py_srvsvc_NetSrvInfo599_get_initfiletable, py_srvsvc_NetSrvInfo599_set_initfiletable },
	{ discard_const_p(char, "initsearchtable"), py_srvsvc_NetSrvInfo599_get_initsearchtable, py_srvsvc_NetSrvInfo599_set_initsearchtable },
	{ discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo599_get_alertsched, py_srvsvc_NetSrvInfo599_set_alertsched },
	{ discard_const_p(char, "errortreshold"), py_srvsvc_NetSrvInfo599_get_errortreshold, py_srvsvc_NetSrvInfo599_set_errortreshold },
	{ discard_const_p(char, "networkerrortreshold"), py_srvsvc_NetSrvInfo599_get_networkerrortreshold, py_srvsvc_NetSrvInfo599_set_networkerrortreshold },
	{ discard_const_p(char, "diskspacetreshold"), py_srvsvc_NetSrvInfo599_get_diskspacetreshold, py_srvsvc_NetSrvInfo599_set_diskspacetreshold },
	{ discard_const_p(char, "reserved"), py_srvsvc_NetSrvInfo599_get_reserved, py_srvsvc_NetSrvInfo599_set_reserved },
	{ discard_const_p(char, "maxlinkdelay"), py_srvsvc_NetSrvInfo599_get_maxlinkdelay, py_srvsvc_NetSrvInfo599_set_maxlinkdelay },
	{ discard_const_p(char, "minlinkthroughput"), py_srvsvc_NetSrvInfo599_get_minlinkthroughput, py_srvsvc_NetSrvInfo599_set_minlinkthroughput },
	{ discard_const_p(char, "linkinfovalidtime"), py_srvsvc_NetSrvInfo599_get_linkinfovalidtime, py_srvsvc_NetSrvInfo599_set_linkinfovalidtime },
	{ discard_const_p(char, "scavqosinfoupdatetime"), py_srvsvc_NetSrvInfo599_get_scavqosinfoupdatetime, py_srvsvc_NetSrvInfo599_set_scavqosinfoupdatetime },
	{ discard_const_p(char, "maxworkitemidletime"), py_srvsvc_NetSrvInfo599_get_maxworkitemidletime, py_srvsvc_NetSrvInfo599_set_maxworkitemidletime },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo599_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo599, type);
}


static PyTypeObject srvsvc_NetSrvInfo599_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo599",
	.tp_getset = py_srvsvc_NetSrvInfo599_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo599_new,
};


static PyObject *py_srvsvc_NetSrvInfo1005_get_comment(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1005 *object = (struct srvsvc_NetSrvInfo1005 *)pytalloc_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_srvsvc_NetSrvInfo1005_set_comment(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1005 *object = (struct srvsvc_NetSrvInfo1005 *)pytalloc_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_srvsvc_NetSrvInfo1005_getsetters[] = {
	{ discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo1005_get_comment, py_srvsvc_NetSrvInfo1005_set_comment },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1005, type);
}


static PyTypeObject srvsvc_NetSrvInfo1005_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1005",
	.tp_getset = py_srvsvc_NetSrvInfo1005_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1005_new,
};


static PyObject *py_srvsvc_NetSrvInfo1010_get_disc(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1010 *object = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(obj);
	PyObject *py_disc;
	py_disc = PyInt_FromLong(object->disc);
	return py_disc;
}

static int py_srvsvc_NetSrvInfo1010_set_disc(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1010 *object = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->disc = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1010_getsetters[] = {
	{ discard_const_p(char, "disc"), py_srvsvc_NetSrvInfo1010_get_disc, py_srvsvc_NetSrvInfo1010_set_disc },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1010_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1010, type);
}


static PyTypeObject srvsvc_NetSrvInfo1010_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1010",
	.tp_getset = py_srvsvc_NetSrvInfo1010_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1010_new,
};


static PyObject *py_srvsvc_NetSrvInfo1016_get_hidden(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1016 *object = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(obj);
	PyObject *py_hidden;
	py_hidden = PyInt_FromLong(object->hidden);
	return py_hidden;
}

static int py_srvsvc_NetSrvInfo1016_set_hidden(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1016 *object = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->hidden = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1016_getsetters[] = {
	{ discard_const_p(char, "hidden"), py_srvsvc_NetSrvInfo1016_get_hidden, py_srvsvc_NetSrvInfo1016_set_hidden },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1016_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1016, type);
}


static PyTypeObject srvsvc_NetSrvInfo1016_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1016",
	.tp_getset = py_srvsvc_NetSrvInfo1016_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1016_new,
};


static PyObject *py_srvsvc_NetSrvInfo1017_get_announce(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1017 *object = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(obj);
	PyObject *py_announce;
	py_announce = PyInt_FromLong(object->announce);
	return py_announce;
}

static int py_srvsvc_NetSrvInfo1017_set_announce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1017 *object = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->announce = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1017_getsetters[] = {
	{ discard_const_p(char, "announce"), py_srvsvc_NetSrvInfo1017_get_announce, py_srvsvc_NetSrvInfo1017_set_announce },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1017_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1017, type);
}


static PyTypeObject srvsvc_NetSrvInfo1017_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1017",
	.tp_getset = py_srvsvc_NetSrvInfo1017_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1017_new,
};


static PyObject *py_srvsvc_NetSrvInfo1018_get_anndelta(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1018 *object = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(obj);
	PyObject *py_anndelta;
	py_anndelta = PyInt_FromLong(object->anndelta);
	return py_anndelta;
}

static int py_srvsvc_NetSrvInfo1018_set_anndelta(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1018 *object = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->anndelta = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1018_getsetters[] = {
	{ discard_const_p(char, "anndelta"), py_srvsvc_NetSrvInfo1018_get_anndelta, py_srvsvc_NetSrvInfo1018_set_anndelta },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1018_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1018, type);
}


static PyTypeObject srvsvc_NetSrvInfo1018_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1018",
	.tp_getset = py_srvsvc_NetSrvInfo1018_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1018_new,
};


static PyObject *py_srvsvc_NetSrvInfo1107_get_users(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1107 *object = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(obj);
	PyObject *py_users;
	py_users = PyInt_FromLong(object->users);
	return py_users;
}

static int py_srvsvc_NetSrvInfo1107_set_users(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1107 *object = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->users = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1107_getsetters[] = {
	{ discard_const_p(char, "users"), py_srvsvc_NetSrvInfo1107_get_users, py_srvsvc_NetSrvInfo1107_set_users },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1107_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1107, type);
}


static PyTypeObject srvsvc_NetSrvInfo1107_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1107",
	.tp_getset = py_srvsvc_NetSrvInfo1107_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1107_new,
};


static PyObject *py_srvsvc_NetSrvInfo1501_get_sessopens(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1501 *object = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(obj);
	PyObject *py_sessopens;
	py_sessopens = PyInt_FromLong(object->sessopens);
	return py_sessopens;
}

static int py_srvsvc_NetSrvInfo1501_set_sessopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1501 *object = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessopens = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1501_getsetters[] = {
	{ discard_const_p(char, "sessopens"), py_srvsvc_NetSrvInfo1501_get_sessopens, py_srvsvc_NetSrvInfo1501_set_sessopens },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1501, type);
}


static PyTypeObject srvsvc_NetSrvInfo1501_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1501",
	.tp_getset = py_srvsvc_NetSrvInfo1501_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1501_new,
};


static PyObject *py_srvsvc_NetSrvInfo1502_get_sessvcs(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1502 *object = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(obj);
	PyObject *py_sessvcs;
	py_sessvcs = PyInt_FromLong(object->sessvcs);
	return py_sessvcs;
}

static int py_srvsvc_NetSrvInfo1502_set_sessvcs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1502 *object = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessvcs = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1502_getsetters[] = {
	{ discard_const_p(char, "sessvcs"), py_srvsvc_NetSrvInfo1502_get_sessvcs, py_srvsvc_NetSrvInfo1502_set_sessvcs },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1502, type);
}


static PyTypeObject srvsvc_NetSrvInfo1502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1502",
	.tp_getset = py_srvsvc_NetSrvInfo1502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1502_new,
};


static PyObject *py_srvsvc_NetSrvInfo1503_get_opensearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1503 *object = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(obj);
	PyObject *py_opensearch;
	py_opensearch = PyInt_FromLong(object->opensearch);
	return py_opensearch;
}

static int py_srvsvc_NetSrvInfo1503_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1503 *object = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->opensearch = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1503_getsetters[] = {
	{ discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo1503_get_opensearch, py_srvsvc_NetSrvInfo1503_set_opensearch },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1503_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1503, type);
}


static PyTypeObject srvsvc_NetSrvInfo1503_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1503",
	.tp_getset = py_srvsvc_NetSrvInfo1503_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1503_new,
};


static PyObject *py_srvsvc_NetSrvInfo1506_get_maxworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1506 *object = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(obj);
	PyObject *py_maxworkitems;
	py_maxworkitems = PyInt_FromLong(object->maxworkitems);
	return py_maxworkitems;
}

static int py_srvsvc_NetSrvInfo1506_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1506 *object = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxworkitems = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1506_getsetters[] = {
	{ discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo1506_get_maxworkitems, py_srvsvc_NetSrvInfo1506_set_maxworkitems },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1506_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1506, type);
}


static PyTypeObject srvsvc_NetSrvInfo1506_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1506",
	.tp_getset = py_srvsvc_NetSrvInfo1506_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1506_new,
};


static PyObject *py_srvsvc_NetSrvInfo1509_get_maxrawbuflen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1509 *object = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(obj);
	PyObject *py_maxrawbuflen;
	py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
	return py_maxrawbuflen;
}

static int py_srvsvc_NetSrvInfo1509_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1509 *object = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxrawbuflen = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1509_getsetters[] = {
	{ discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo1509_get_maxrawbuflen, py_srvsvc_NetSrvInfo1509_set_maxrawbuflen },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1509_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1509, type);
}


static PyTypeObject srvsvc_NetSrvInfo1509_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1509",
	.tp_getset = py_srvsvc_NetSrvInfo1509_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1509_new,
};


static PyObject *py_srvsvc_NetSrvInfo1510_get_sessusers(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1510 *object = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(obj);
	PyObject *py_sessusers;
	py_sessusers = PyInt_FromLong(object->sessusers);
	return py_sessusers;
}

static int py_srvsvc_NetSrvInfo1510_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1510 *object = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sessusers = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1510_getsetters[] = {
	{ discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo1510_get_sessusers, py_srvsvc_NetSrvInfo1510_set_sessusers },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1510_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1510, type);
}


static PyTypeObject srvsvc_NetSrvInfo1510_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1510",
	.tp_getset = py_srvsvc_NetSrvInfo1510_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1510_new,
};


static PyObject *py_srvsvc_NetSrvInfo1511_get_sesscons(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1511 *object = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(obj);
	PyObject *py_sesscons;
	py_sesscons = PyInt_FromLong(object->sesscons);
	return py_sesscons;
}

static int py_srvsvc_NetSrvInfo1511_set_sesscons(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1511 *object = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sesscons = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1511_getsetters[] = {
	{ discard_const_p(char, "sesscons"), py_srvsvc_NetSrvInfo1511_get_sesscons, py_srvsvc_NetSrvInfo1511_set_sesscons },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1511_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1511, type);
}


static PyTypeObject srvsvc_NetSrvInfo1511_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1511",
	.tp_getset = py_srvsvc_NetSrvInfo1511_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1511_new,
};


static PyObject *py_srvsvc_NetSrvInfo1512_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1512 *object = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(obj);
	PyObject *py_maxnonpagedmemoryusage;
	py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
	return py_maxnonpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo1512_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1512 *object = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxnonpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1512_getsetters[] = {
	{ discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo1512_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo1512_set_maxnonpagedmemoryusage },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1512_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1512, type);
}


static PyTypeObject srvsvc_NetSrvInfo1512_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1512",
	.tp_getset = py_srvsvc_NetSrvInfo1512_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1512_new,
};


static PyObject *py_srvsvc_NetSrvInfo1513_get_maxpagedmemoryusage(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1513 *object = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(obj);
	PyObject *py_maxpagedmemoryusage;
	py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
	return py_maxpagedmemoryusage;
}

static int py_srvsvc_NetSrvInfo1513_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1513 *object = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxpagedmemoryusage = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1513_getsetters[] = {
	{ discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo1513_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo1513_set_maxpagedmemoryusage },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1513_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1513, type);
}


static PyTypeObject srvsvc_NetSrvInfo1513_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1513",
	.tp_getset = py_srvsvc_NetSrvInfo1513_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1513_new,
};


static PyObject *py_srvsvc_NetSrvInfo1514_get_enablesoftcompat(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1514 *object = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesoftcompat;
	py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
	return py_enablesoftcompat;
}

static int py_srvsvc_NetSrvInfo1514_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1514 *object = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesoftcompat = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1514_getsetters[] = {
	{ discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo1514_get_enablesoftcompat, py_srvsvc_NetSrvInfo1514_set_enablesoftcompat },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1514_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1514, type);
}


static PyTypeObject srvsvc_NetSrvInfo1514_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1514",
	.tp_getset = py_srvsvc_NetSrvInfo1514_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1514_new,
};


static PyObject *py_srvsvc_NetSrvInfo1515_get_enableforcedlogoff(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1515 *object = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(obj);
	PyObject *py_enableforcedlogoff;
	py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
	return py_enableforcedlogoff;
}

static int py_srvsvc_NetSrvInfo1515_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1515 *object = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableforcedlogoff = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1515_getsetters[] = {
	{ discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo1515_get_enableforcedlogoff, py_srvsvc_NetSrvInfo1515_set_enableforcedlogoff },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1515_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1515, type);
}


static PyTypeObject srvsvc_NetSrvInfo1515_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1515",
	.tp_getset = py_srvsvc_NetSrvInfo1515_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1515_new,
};


static PyObject *py_srvsvc_NetSrvInfo1516_get_timesource(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1516 *object = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(obj);
	PyObject *py_timesource;
	py_timesource = PyInt_FromLong(object->timesource);
	return py_timesource;
}

static int py_srvsvc_NetSrvInfo1516_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1516 *object = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timesource = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1516_getsetters[] = {
	{ discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo1516_get_timesource, py_srvsvc_NetSrvInfo1516_set_timesource },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1516_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1516, type);
}


static PyTypeObject srvsvc_NetSrvInfo1516_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1516",
	.tp_getset = py_srvsvc_NetSrvInfo1516_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1516_new,
};


static PyObject *py_srvsvc_NetSrvInfo1518_get_lmannounce(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1518 *object = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(obj);
	PyObject *py_lmannounce;
	py_lmannounce = PyInt_FromLong(object->lmannounce);
	return py_lmannounce;
}

static int py_srvsvc_NetSrvInfo1518_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1518 *object = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->lmannounce = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1518_getsetters[] = {
	{ discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo1518_get_lmannounce, py_srvsvc_NetSrvInfo1518_set_lmannounce },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1518_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1518, type);
}


static PyTypeObject srvsvc_NetSrvInfo1518_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1518",
	.tp_getset = py_srvsvc_NetSrvInfo1518_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1518_new,
};


static PyObject *py_srvsvc_NetSrvInfo1520_get_maxcopyreadlen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1520 *object = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(obj);
	PyObject *py_maxcopyreadlen;
	py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
	return py_maxcopyreadlen;
}

static int py_srvsvc_NetSrvInfo1520_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1520 *object = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxcopyreadlen = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1520_getsetters[] = {
	{ discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo1520_get_maxcopyreadlen, py_srvsvc_NetSrvInfo1520_set_maxcopyreadlen },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1520_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1520, type);
}


static PyTypeObject srvsvc_NetSrvInfo1520_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1520",
	.tp_getset = py_srvsvc_NetSrvInfo1520_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1520_new,
};


static PyObject *py_srvsvc_NetSrvInfo1521_get_maxcopywritelen(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1521 *object = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(obj);
	PyObject *py_maxcopywritelen;
	py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
	return py_maxcopywritelen;
}

static int py_srvsvc_NetSrvInfo1521_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1521 *object = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxcopywritelen = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1521_getsetters[] = {
	{ discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo1521_get_maxcopywritelen, py_srvsvc_NetSrvInfo1521_set_maxcopywritelen },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1521_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1521, type);
}


static PyTypeObject srvsvc_NetSrvInfo1521_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1521",
	.tp_getset = py_srvsvc_NetSrvInfo1521_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1521_new,
};


static PyObject *py_srvsvc_NetSrvInfo1522_get_minkeepsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1522 *object = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(obj);
	PyObject *py_minkeepsearch;
	py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
	return py_minkeepsearch;
}

static int py_srvsvc_NetSrvInfo1522_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1522 *object = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minkeepsearch = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1522_getsetters[] = {
	{ discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo1522_get_minkeepsearch, py_srvsvc_NetSrvInfo1522_set_minkeepsearch },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1522_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1522, type);
}


static PyTypeObject srvsvc_NetSrvInfo1522_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1522",
	.tp_getset = py_srvsvc_NetSrvInfo1522_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1522_new,
};


static PyObject *py_srvsvc_NetSrvInfo1523_get_maxkeepsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1523 *object = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(obj);
	PyObject *py_maxkeepsearch;
	py_maxkeepsearch = PyInt_FromLong(object->maxkeepsearch);
	return py_maxkeepsearch;
}

static int py_srvsvc_NetSrvInfo1523_set_maxkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1523 *object = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxkeepsearch = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1523_getsetters[] = {
	{ discard_const_p(char, "maxkeepsearch"), py_srvsvc_NetSrvInfo1523_get_maxkeepsearch, py_srvsvc_NetSrvInfo1523_set_maxkeepsearch },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1523_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1523, type);
}


static PyTypeObject srvsvc_NetSrvInfo1523_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1523",
	.tp_getset = py_srvsvc_NetSrvInfo1523_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1523_new,
};


static PyObject *py_srvsvc_NetSrvInfo1524_get_minkeepcomplsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1524 *object = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(obj);
	PyObject *py_minkeepcomplsearch;
	py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
	return py_minkeepcomplsearch;
}

static int py_srvsvc_NetSrvInfo1524_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1524 *object = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minkeepcomplsearch = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1524_getsetters[] = {
	{ discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo1524_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo1524_set_minkeepcomplsearch },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1524_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1524, type);
}


static PyTypeObject srvsvc_NetSrvInfo1524_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1524",
	.tp_getset = py_srvsvc_NetSrvInfo1524_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1524_new,
};


static PyObject *py_srvsvc_NetSrvInfo1525_get_maxkeepcomplsearch(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1525 *object = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(obj);
	PyObject *py_maxkeepcomplsearch;
	py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
	return py_maxkeepcomplsearch;
}

static int py_srvsvc_NetSrvInfo1525_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1525 *object = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxkeepcomplsearch = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1525_getsetters[] = {
	{ discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo1525_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo1525_set_maxkeepcomplsearch },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1525_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1525, type);
}


static PyTypeObject srvsvc_NetSrvInfo1525_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1525",
	.tp_getset = py_srvsvc_NetSrvInfo1525_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1525_new,
};


static PyObject *py_srvsvc_NetSrvInfo1528_get_scavtimeout(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1528 *object = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(obj);
	PyObject *py_scavtimeout;
	py_scavtimeout = PyInt_FromLong(object->scavtimeout);
	return py_scavtimeout;
}

static int py_srvsvc_NetSrvInfo1528_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1528 *object = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->scavtimeout = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1528_getsetters[] = {
	{ discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo1528_get_scavtimeout, py_srvsvc_NetSrvInfo1528_set_scavtimeout },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1528_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1528, type);
}


static PyTypeObject srvsvc_NetSrvInfo1528_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1528",
	.tp_getset = py_srvsvc_NetSrvInfo1528_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1528_new,
};


static PyObject *py_srvsvc_NetSrvInfo1529_get_minrcvqueue(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1529 *object = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(obj);
	PyObject *py_minrcvqueue;
	py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
	return py_minrcvqueue;
}

static int py_srvsvc_NetSrvInfo1529_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1529 *object = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minrcvqueue = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1529_getsetters[] = {
	{ discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo1529_get_minrcvqueue, py_srvsvc_NetSrvInfo1529_set_minrcvqueue },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1529_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1529, type);
}


static PyTypeObject srvsvc_NetSrvInfo1529_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1529",
	.tp_getset = py_srvsvc_NetSrvInfo1529_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1529_new,
};


static PyObject *py_srvsvc_NetSrvInfo1530_get_minfreeworkitems(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1530 *object = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(obj);
	PyObject *py_minfreeworkitems;
	py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
	return py_minfreeworkitems;
}

static int py_srvsvc_NetSrvInfo1530_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1530 *object = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minfreeworkitems = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1530_getsetters[] = {
	{ discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo1530_get_minfreeworkitems, py_srvsvc_NetSrvInfo1530_set_minfreeworkitems },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1530_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1530, type);
}


static PyTypeObject srvsvc_NetSrvInfo1530_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1530",
	.tp_getset = py_srvsvc_NetSrvInfo1530_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1530_new,
};


static PyObject *py_srvsvc_NetSrvInfo1533_get_maxmpxct(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1533 *object = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(obj);
	PyObject *py_maxmpxct;
	py_maxmpxct = PyInt_FromLong(object->maxmpxct);
	return py_maxmpxct;
}

static int py_srvsvc_NetSrvInfo1533_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1533 *object = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxmpxct = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1533_getsetters[] = {
	{ discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo1533_get_maxmpxct, py_srvsvc_NetSrvInfo1533_set_maxmpxct },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1533_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1533, type);
}


static PyTypeObject srvsvc_NetSrvInfo1533_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1533",
	.tp_getset = py_srvsvc_NetSrvInfo1533_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1533_new,
};


static PyObject *py_srvsvc_NetSrvInfo1534_get_oplockbreakwait(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1534 *object = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(obj);
	PyObject *py_oplockbreakwait;
	py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
	return py_oplockbreakwait;
}

static int py_srvsvc_NetSrvInfo1534_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1534 *object = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->oplockbreakwait = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1534_getsetters[] = {
	{ discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo1534_get_oplockbreakwait, py_srvsvc_NetSrvInfo1534_set_oplockbreakwait },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1534_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1534, type);
}


static PyTypeObject srvsvc_NetSrvInfo1534_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1534",
	.tp_getset = py_srvsvc_NetSrvInfo1534_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1534_new,
};


static PyObject *py_srvsvc_NetSrvInfo1535_get_oplockbreakresponsewait(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1535 *object = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(obj);
	PyObject *py_oplockbreakresponsewait;
	py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
	return py_oplockbreakresponsewait;
}

static int py_srvsvc_NetSrvInfo1535_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1535 *object = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->oplockbreakresponsewait = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1535_getsetters[] = {
	{ discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo1535_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo1535_set_oplockbreakresponsewait },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1535_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1535, type);
}


static PyTypeObject srvsvc_NetSrvInfo1535_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1535",
	.tp_getset = py_srvsvc_NetSrvInfo1535_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1535_new,
};


static PyObject *py_srvsvc_NetSrvInfo1536_get_enableoplocks(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1536 *object = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(obj);
	PyObject *py_enableoplocks;
	py_enableoplocks = PyInt_FromLong(object->enableoplocks);
	return py_enableoplocks;
}

static int py_srvsvc_NetSrvInfo1536_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1536 *object = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableoplocks = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1536_getsetters[] = {
	{ discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo1536_get_enableoplocks, py_srvsvc_NetSrvInfo1536_set_enableoplocks },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1536_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1536, type);
}


static PyTypeObject srvsvc_NetSrvInfo1536_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1536",
	.tp_getset = py_srvsvc_NetSrvInfo1536_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1536_new,
};


static PyObject *py_srvsvc_NetSrvInfo1537_get_enableoplockforceclose(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1537 *object = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(obj);
	PyObject *py_enableoplockforceclose;
	py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
	return py_enableoplockforceclose;
}

static int py_srvsvc_NetSrvInfo1537_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1537 *object = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableoplockforceclose = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1537_getsetters[] = {
	{ discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo1537_get_enableoplockforceclose, py_srvsvc_NetSrvInfo1537_set_enableoplockforceclose },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1537_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1537, type);
}


static PyTypeObject srvsvc_NetSrvInfo1537_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1537",
	.tp_getset = py_srvsvc_NetSrvInfo1537_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1537_new,
};


static PyObject *py_srvsvc_NetSrvInfo1538_get_enablefcbopens(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1538 *object = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(obj);
	PyObject *py_enablefcbopens;
	py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
	return py_enablefcbopens;
}

static int py_srvsvc_NetSrvInfo1538_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1538 *object = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablefcbopens = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1538_getsetters[] = {
	{ discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo1538_get_enablefcbopens, py_srvsvc_NetSrvInfo1538_set_enablefcbopens },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1538_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1538, type);
}


static PyTypeObject srvsvc_NetSrvInfo1538_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1538",
	.tp_getset = py_srvsvc_NetSrvInfo1538_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1538_new,
};


static PyObject *py_srvsvc_NetSrvInfo1539_get_enableraw(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1539 *object = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(obj);
	PyObject *py_enableraw;
	py_enableraw = PyInt_FromLong(object->enableraw);
	return py_enableraw;
}

static int py_srvsvc_NetSrvInfo1539_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1539 *object = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enableraw = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1539_getsetters[] = {
	{ discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo1539_get_enableraw, py_srvsvc_NetSrvInfo1539_set_enableraw },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1539_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1539, type);
}


static PyTypeObject srvsvc_NetSrvInfo1539_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1539",
	.tp_getset = py_srvsvc_NetSrvInfo1539_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1539_new,
};


static PyObject *py_srvsvc_NetSrvInfo1540_get_enablesharednetdrives(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1540 *object = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(obj);
	PyObject *py_enablesharednetdrives;
	py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
	return py_enablesharednetdrives;
}

static int py_srvsvc_NetSrvInfo1540_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1540 *object = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->enablesharednetdrives = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1540_getsetters[] = {
	{ discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo1540_get_enablesharednetdrives, py_srvsvc_NetSrvInfo1540_set_enablesharednetdrives },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1540_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1540, type);
}


static PyTypeObject srvsvc_NetSrvInfo1540_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1540",
	.tp_getset = py_srvsvc_NetSrvInfo1540_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1540_new,
};


static PyObject *py_srvsvc_NetSrvInfo1541_get_minfreeconnections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1541 *object = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(obj);
	PyObject *py_minfreeconnections;
	py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
	return py_minfreeconnections;
}

static int py_srvsvc_NetSrvInfo1541_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1541 *object = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minfreeconnections = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1541_getsetters[] = {
	{ discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo1541_get_minfreeconnections, py_srvsvc_NetSrvInfo1541_set_minfreeconnections },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1541_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1541, type);
}


static PyTypeObject srvsvc_NetSrvInfo1541_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1541",
	.tp_getset = py_srvsvc_NetSrvInfo1541_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1541_new,
};


static PyObject *py_srvsvc_NetSrvInfo1542_get_maxfreeconnections(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1542 *object = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(obj);
	PyObject *py_maxfreeconnections;
	py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
	return py_maxfreeconnections;
}

static int py_srvsvc_NetSrvInfo1542_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1542 *object = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxfreeconnections = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1542_getsetters[] = {
	{ discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo1542_get_maxfreeconnections, py_srvsvc_NetSrvInfo1542_set_maxfreeconnections },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1542_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1542, type);
}


static PyTypeObject srvsvc_NetSrvInfo1542_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1542",
	.tp_getset = py_srvsvc_NetSrvInfo1542_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1542_new,
};


static PyObject *py_srvsvc_NetSrvInfo1543_get_initsesstable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1543 *object = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(obj);
	PyObject *py_initsesstable;
	py_initsesstable = PyInt_FromLong(object->initsesstable);
	return py_initsesstable;
}

static int py_srvsvc_NetSrvInfo1543_set_initsesstable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1543 *object = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initsesstable = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1543_getsetters[] = {
	{ discard_const_p(char, "initsesstable"), py_srvsvc_NetSrvInfo1543_get_initsesstable, py_srvsvc_NetSrvInfo1543_set_initsesstable },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1543_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1543, type);
}


static PyTypeObject srvsvc_NetSrvInfo1543_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1543",
	.tp_getset = py_srvsvc_NetSrvInfo1543_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1543_new,
};


static PyObject *py_srvsvc_NetSrvInfo1544_get_initconntable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1544 *object = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(obj);
	PyObject *py_initconntable;
	py_initconntable = PyInt_FromLong(object->initconntable);
	return py_initconntable;
}

static int py_srvsvc_NetSrvInfo1544_set_initconntable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1544 *object = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initconntable = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1544_getsetters[] = {
	{ discard_const_p(char, "initconntable"), py_srvsvc_NetSrvInfo1544_get_initconntable, py_srvsvc_NetSrvInfo1544_set_initconntable },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1544_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1544, type);
}


static PyTypeObject srvsvc_NetSrvInfo1544_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1544",
	.tp_getset = py_srvsvc_NetSrvInfo1544_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1544_new,
};


static PyObject *py_srvsvc_NetSrvInfo1545_get_initfiletable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1545 *object = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(obj);
	PyObject *py_initfiletable;
	py_initfiletable = PyInt_FromLong(object->initfiletable);
	return py_initfiletable;
}

static int py_srvsvc_NetSrvInfo1545_set_initfiletable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1545 *object = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initfiletable = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1545_getsetters[] = {
	{ discard_const_p(char, "initfiletable"), py_srvsvc_NetSrvInfo1545_get_initfiletable, py_srvsvc_NetSrvInfo1545_set_initfiletable },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1545_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1545, type);
}


static PyTypeObject srvsvc_NetSrvInfo1545_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1545",
	.tp_getset = py_srvsvc_NetSrvInfo1545_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1545_new,
};


static PyObject *py_srvsvc_NetSrvInfo1546_get_initsearchtable(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1546 *object = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(obj);
	PyObject *py_initsearchtable;
	py_initsearchtable = PyInt_FromLong(object->initsearchtable);
	return py_initsearchtable;
}

static int py_srvsvc_NetSrvInfo1546_set_initsearchtable(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1546 *object = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->initsearchtable = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1546_getsetters[] = {
	{ discard_const_p(char, "initsearchtable"), py_srvsvc_NetSrvInfo1546_get_initsearchtable, py_srvsvc_NetSrvInfo1546_set_initsearchtable },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1546_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1546, type);
}


static PyTypeObject srvsvc_NetSrvInfo1546_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1546",
	.tp_getset = py_srvsvc_NetSrvInfo1546_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1546_new,
};


static PyObject *py_srvsvc_NetSrvInfo1547_get_alertsched(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1547 *object = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(obj);
	PyObject *py_alertsched;
	py_alertsched = PyInt_FromLong(object->alertsched);
	return py_alertsched;
}

static int py_srvsvc_NetSrvInfo1547_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1547 *object = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->alertsched = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1547_getsetters[] = {
	{ discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo1547_get_alertsched, py_srvsvc_NetSrvInfo1547_set_alertsched },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1547_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1547, type);
}


static PyTypeObject srvsvc_NetSrvInfo1547_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1547",
	.tp_getset = py_srvsvc_NetSrvInfo1547_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1547_new,
};


static PyObject *py_srvsvc_NetSrvInfo1548_get_errortreshold(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1548 *object = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(obj);
	PyObject *py_errortreshold;
	py_errortreshold = PyInt_FromLong(object->errortreshold);
	return py_errortreshold;
}

static int py_srvsvc_NetSrvInfo1548_set_errortreshold(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1548 *object = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->errortreshold = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1548_getsetters[] = {
	{ discard_const_p(char, "errortreshold"), py_srvsvc_NetSrvInfo1548_get_errortreshold, py_srvsvc_NetSrvInfo1548_set_errortreshold },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1548_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1548, type);
}


static PyTypeObject srvsvc_NetSrvInfo1548_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1548",
	.tp_getset = py_srvsvc_NetSrvInfo1548_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1548_new,
};


static PyObject *py_srvsvc_NetSrvInfo1549_get_networkerrortreshold(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1549 *object = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(obj);
	PyObject *py_networkerrortreshold;
	py_networkerrortreshold = PyInt_FromLong(object->networkerrortreshold);
	return py_networkerrortreshold;
}

static int py_srvsvc_NetSrvInfo1549_set_networkerrortreshold(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1549 *object = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->networkerrortreshold = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1549_getsetters[] = {
	{ discard_const_p(char, "networkerrortreshold"), py_srvsvc_NetSrvInfo1549_get_networkerrortreshold, py_srvsvc_NetSrvInfo1549_set_networkerrortreshold },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1549_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1549, type);
}


static PyTypeObject srvsvc_NetSrvInfo1549_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1549",
	.tp_getset = py_srvsvc_NetSrvInfo1549_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1549_new,
};


static PyObject *py_srvsvc_NetSrvInfo1550_get_diskspacetreshold(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1550 *object = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(obj);
	PyObject *py_diskspacetreshold;
	py_diskspacetreshold = PyInt_FromLong(object->diskspacetreshold);
	return py_diskspacetreshold;
}

static int py_srvsvc_NetSrvInfo1550_set_diskspacetreshold(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1550 *object = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->diskspacetreshold = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1550_getsetters[] = {
	{ discard_const_p(char, "diskspacetreshold"), py_srvsvc_NetSrvInfo1550_get_diskspacetreshold, py_srvsvc_NetSrvInfo1550_set_diskspacetreshold },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1550_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1550, type);
}


static PyTypeObject srvsvc_NetSrvInfo1550_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1550",
	.tp_getset = py_srvsvc_NetSrvInfo1550_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1550_new,
};


static PyObject *py_srvsvc_NetSrvInfo1552_get_maxlinkdelay(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1552 *object = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(obj);
	PyObject *py_maxlinkdelay;
	py_maxlinkdelay = PyInt_FromLong(object->maxlinkdelay);
	return py_maxlinkdelay;
}

static int py_srvsvc_NetSrvInfo1552_set_maxlinkdelay(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1552 *object = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxlinkdelay = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1552_getsetters[] = {
	{ discard_const_p(char, "maxlinkdelay"), py_srvsvc_NetSrvInfo1552_get_maxlinkdelay, py_srvsvc_NetSrvInfo1552_set_maxlinkdelay },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1552_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1552, type);
}


static PyTypeObject srvsvc_NetSrvInfo1552_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1552",
	.tp_getset = py_srvsvc_NetSrvInfo1552_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1552_new,
};


static PyObject *py_srvsvc_NetSrvInfo1553_get_minlinkthroughput(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1553 *object = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(obj);
	PyObject *py_minlinkthroughput;
	py_minlinkthroughput = PyInt_FromLong(object->minlinkthroughput);
	return py_minlinkthroughput;
}

static int py_srvsvc_NetSrvInfo1553_set_minlinkthroughput(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1553 *object = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->minlinkthroughput = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1553_getsetters[] = {
	{ discard_const_p(char, "minlinkthroughput"), py_srvsvc_NetSrvInfo1553_get_minlinkthroughput, py_srvsvc_NetSrvInfo1553_set_minlinkthroughput },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1553_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1553, type);
}


static PyTypeObject srvsvc_NetSrvInfo1553_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1553",
	.tp_getset = py_srvsvc_NetSrvInfo1553_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1553_new,
};


static PyObject *py_srvsvc_NetSrvInfo1554_get_linkinfovalidtime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1554 *object = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(obj);
	PyObject *py_linkinfovalidtime;
	py_linkinfovalidtime = PyInt_FromLong(object->linkinfovalidtime);
	return py_linkinfovalidtime;
}

static int py_srvsvc_NetSrvInfo1554_set_linkinfovalidtime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1554 *object = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->linkinfovalidtime = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1554_getsetters[] = {
	{ discard_const_p(char, "linkinfovalidtime"), py_srvsvc_NetSrvInfo1554_get_linkinfovalidtime, py_srvsvc_NetSrvInfo1554_set_linkinfovalidtime },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1554_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1554, type);
}


static PyTypeObject srvsvc_NetSrvInfo1554_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1554",
	.tp_getset = py_srvsvc_NetSrvInfo1554_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1554_new,
};


static PyObject *py_srvsvc_NetSrvInfo1555_get_scavqosinfoupdatetime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1555 *object = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(obj);
	PyObject *py_scavqosinfoupdatetime;
	py_scavqosinfoupdatetime = PyInt_FromLong(object->scavqosinfoupdatetime);
	return py_scavqosinfoupdatetime;
}

static int py_srvsvc_NetSrvInfo1555_set_scavqosinfoupdatetime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1555 *object = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->scavqosinfoupdatetime = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1555_getsetters[] = {
	{ discard_const_p(char, "scavqosinfoupdatetime"), py_srvsvc_NetSrvInfo1555_get_scavqosinfoupdatetime, py_srvsvc_NetSrvInfo1555_set_scavqosinfoupdatetime },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1555_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1555, type);
}


static PyTypeObject srvsvc_NetSrvInfo1555_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1555",
	.tp_getset = py_srvsvc_NetSrvInfo1555_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1555_new,
};


static PyObject *py_srvsvc_NetSrvInfo1556_get_maxworkitemidletime(PyObject *obj, void *closure)
{
	struct srvsvc_NetSrvInfo1556 *object = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(obj);
	PyObject *py_maxworkitemidletime;
	py_maxworkitemidletime = PyInt_FromLong(object->maxworkitemidletime);
	return py_maxworkitemidletime;
}

static int py_srvsvc_NetSrvInfo1556_set_maxworkitemidletime(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetSrvInfo1556 *object = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->maxworkitemidletime = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetSrvInfo1556_getsetters[] = {
	{ discard_const_p(char, "maxworkitemidletime"), py_srvsvc_NetSrvInfo1556_get_maxworkitemidletime, py_srvsvc_NetSrvInfo1556_set_maxworkitemidletime },
	{ NULL }
};

static PyObject *py_srvsvc_NetSrvInfo1556_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetSrvInfo1556, type);
}


static PyTypeObject srvsvc_NetSrvInfo1556_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetSrvInfo1556",
	.tp_getset = py_srvsvc_NetSrvInfo1556_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetSrvInfo1556_new,
};

PyObject *py_import_srvsvc_NetSrvInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetSrvInfo *in)
{
	PyObject *ret;

	switch (level) {
		case 100:
			if (in->info100 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo100_Type, in->info100, in->info100);
			}
			return ret;

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

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

		case 402:
			if (in->info402 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo402_Type, in->info402, in->info402);
			}
			return ret;

		case 403:
			if (in->info403 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo403_Type, in->info403, in->info403);
			}
			return ret;

		case 502:
			if (in->info502 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo502_Type, in->info502, in->info502);
			}
			return ret;

		case 503:
			if (in->info503 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo503_Type, in->info503, in->info503);
			}
			return ret;

		case 599:
			if (in->info599 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo599_Type, in->info599, in->info599);
			}
			return ret;

		case 1005:
			if (in->info1005 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1005_Type, in->info1005, in->info1005);
			}
			return ret;

		case 1010:
			if (in->info1010 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1010_Type, in->info1010, in->info1010);
			}
			return ret;

		case 1016:
			if (in->info1016 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1016_Type, in->info1016, in->info1016);
			}
			return ret;

		case 1017:
			if (in->info1017 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1017_Type, in->info1017, in->info1017);
			}
			return ret;

		case 1018:
			if (in->info1018 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1018_Type, in->info1018, in->info1018);
			}
			return ret;

		case 1107:
			if (in->info1107 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1107_Type, in->info1107, in->info1107);
			}
			return ret;

		case 1501:
			if (in->info1501 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1501_Type, in->info1501, in->info1501);
			}
			return ret;

		case 1502:
			if (in->info1502 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1502_Type, in->info1502, in->info1502);
			}
			return ret;

		case 1503:
			if (in->info1503 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1503_Type, in->info1503, in->info1503);
			}
			return ret;

		case 1506:
			if (in->info1506 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1506_Type, in->info1506, in->info1506);
			}
			return ret;

		case 1509:
			if (in->info1509 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1509_Type, in->info1509, in->info1509);
			}
			return ret;

		case 1510:
			if (in->info1510 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1510_Type, in->info1510, in->info1510);
			}
			return ret;

		case 1511:
			if (in->info1511 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1511_Type, in->info1511, in->info1511);
			}
			return ret;

		case 1512:
			if (in->info1512 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1512_Type, in->info1512, in->info1512);
			}
			return ret;

		case 1513:
			if (in->info1513 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1513_Type, in->info1513, in->info1513);
			}
			return ret;

		case 1514:
			if (in->info1514 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1514_Type, in->info1514, in->info1514);
			}
			return ret;

		case 1515:
			if (in->info1515 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1515_Type, in->info1515, in->info1515);
			}
			return ret;

		case 1516:
			if (in->info1516 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1516_Type, in->info1516, in->info1516);
			}
			return ret;

		case 1518:
			if (in->info1518 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1518_Type, in->info1518, in->info1518);
			}
			return ret;

		case 1520:
			if (in->info1520 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1520_Type, in->info1520, in->info1520);
			}
			return ret;

		case 1521:
			if (in->info1521 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1521_Type, in->info1521, in->info1521);
			}
			return ret;

		case 1522:
			if (in->info1522 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1522_Type, in->info1522, in->info1522);
			}
			return ret;

		case 1523:
			if (in->info1523 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1523_Type, in->info1523, in->info1523);
			}
			return ret;

		case 1524:
			if (in->info1524 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1524_Type, in->info1524, in->info1524);
			}
			return ret;

		case 1525:
			if (in->info1525 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1525_Type, in->info1525, in->info1525);
			}
			return ret;

		case 1528:
			if (in->info1528 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1528_Type, in->info1528, in->info1528);
			}
			return ret;

		case 1529:
			if (in->info1529 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1529_Type, in->info1529, in->info1529);
			}
			return ret;

		case 1530:
			if (in->info1530 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1530_Type, in->info1530, in->info1530);
			}
			return ret;

		case 1533:
			if (in->info1533 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1533_Type, in->info1533, in->info1533);
			}
			return ret;

		case 1534:
			if (in->info1534 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1534_Type, in->info1534, in->info1534);
			}
			return ret;

		case 1535:
			if (in->info1535 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1535_Type, in->info1535, in->info1535);
			}
			return ret;

		case 1536:
			if (in->info1536 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1536_Type, in->info1536, in->info1536);
			}
			return ret;

		case 1537:
			if (in->info1537 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1537_Type, in->info1537, in->info1537);
			}
			return ret;

		case 1538:
			if (in->info1538 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1538_Type, in->info1538, in->info1538);
			}
			return ret;

		case 1539:
			if (in->info1539 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1539_Type, in->info1539, in->info1539);
			}
			return ret;

		case 1540:
			if (in->info1540 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1540_Type, in->info1540, in->info1540);
			}
			return ret;

		case 1541:
			if (in->info1541 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1541_Type, in->info1541, in->info1541);
			}
			return ret;

		case 1542:
			if (in->info1542 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1542_Type, in->info1542, in->info1542);
			}
			return ret;

		case 1543:
			if (in->info1543 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1543_Type, in->info1543, in->info1543);
			}
			return ret;

		case 1544:
			if (in->info1544 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1544_Type, in->info1544, in->info1544);
			}
			return ret;

		case 1545:
			if (in->info1545 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1545_Type, in->info1545, in->info1545);
			}
			return ret;

		case 1546:
			if (in->info1546 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1546_Type, in->info1546, in->info1546);
			}
			return ret;

		case 1547:
			if (in->info1547 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1547_Type, in->info1547, in->info1547);
			}
			return ret;

		case 1548:
			if (in->info1548 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1548_Type, in->info1548, in->info1548);
			}
			return ret;

		case 1549:
			if (in->info1549 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1549_Type, in->info1549, in->info1549);
			}
			return ret;

		case 1550:
			if (in->info1550 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1550_Type, in->info1550, in->info1550);
			}
			return ret;

		case 1552:
			if (in->info1552 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1552_Type, in->info1552, in->info1552);
			}
			return ret;

		case 1553:
			if (in->info1553 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1553_Type, in->info1553, in->info1553);
			}
			return ret;

		case 1554:
			if (in->info1554 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1554_Type, in->info1554, in->info1554);
			}
			return ret;

		case 1555:
			if (in->info1555 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1555_Type, in->info1555, in->info1555);
			}
			return ret;

		case 1556:
			if (in->info1556 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1556_Type, in->info1556, in->info1556);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetSrvInfo *py_export_srvsvc_NetSrvInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetSrvInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetSrvInfo);
	switch (level) {
		case 100:
			if (in == Py_None) {
				ret->info100 = NULL;
			} else {
				ret->info100 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo100_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info100 = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(in);
			}
			break;

		case 101:
			if (in == Py_None) {
				ret->info101 = NULL;
			} else {
				ret->info101 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo101_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info101 = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(in);
			}
			break;

		case 102:
			if (in == Py_None) {
				ret->info102 = NULL;
			} else {
				ret->info102 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo102_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info102 = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(in);
			}
			break;

		case 402:
			if (in == Py_None) {
				ret->info402 = NULL;
			} else {
				ret->info402 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo402_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info402 = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(in);
			}
			break;

		case 403:
			if (in == Py_None) {
				ret->info403 = NULL;
			} else {
				ret->info403 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo403_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info403 = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(in);
			}
			break;

		case 502:
			if (in == Py_None) {
				ret->info502 = NULL;
			} else {
				ret->info502 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo502_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info502 = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(in);
			}
			break;

		case 503:
			if (in == Py_None) {
				ret->info503 = NULL;
			} else {
				ret->info503 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo503_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info503 = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(in);
			}
			break;

		case 599:
			if (in == Py_None) {
				ret->info599 = NULL;
			} else {
				ret->info599 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo599_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info599 = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(in);
			}
			break;

		case 1005:
			if (in == Py_None) {
				ret->info1005 = NULL;
			} else {
				ret->info1005 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1005_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1005 = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(in);
			}
			break;

		case 1010:
			if (in == Py_None) {
				ret->info1010 = NULL;
			} else {
				ret->info1010 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1010_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1010 = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(in);
			}
			break;

		case 1016:
			if (in == Py_None) {
				ret->info1016 = NULL;
			} else {
				ret->info1016 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1016_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1016 = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(in);
			}
			break;

		case 1017:
			if (in == Py_None) {
				ret->info1017 = NULL;
			} else {
				ret->info1017 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1017_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1017 = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(in);
			}
			break;

		case 1018:
			if (in == Py_None) {
				ret->info1018 = NULL;
			} else {
				ret->info1018 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1018_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1018 = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(in);
			}
			break;

		case 1107:
			if (in == Py_None) {
				ret->info1107 = NULL;
			} else {
				ret->info1107 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1107_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1107 = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(in);
			}
			break;

		case 1501:
			if (in == Py_None) {
				ret->info1501 = NULL;
			} else {
				ret->info1501 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1501_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1501 = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(in);
			}
			break;

		case 1502:
			if (in == Py_None) {
				ret->info1502 = NULL;
			} else {
				ret->info1502 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1502_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1502 = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(in);
			}
			break;

		case 1503:
			if (in == Py_None) {
				ret->info1503 = NULL;
			} else {
				ret->info1503 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1503_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1503 = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(in);
			}
			break;

		case 1506:
			if (in == Py_None) {
				ret->info1506 = NULL;
			} else {
				ret->info1506 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1506_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1506 = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(in);
			}
			break;

		case 1509:
			if (in == Py_None) {
				ret->info1509 = NULL;
			} else {
				ret->info1509 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1509_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1509 = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(in);
			}
			break;

		case 1510:
			if (in == Py_None) {
				ret->info1510 = NULL;
			} else {
				ret->info1510 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1510_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1510 = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(in);
			}
			break;

		case 1511:
			if (in == Py_None) {
				ret->info1511 = NULL;
			} else {
				ret->info1511 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1511_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1511 = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(in);
			}
			break;

		case 1512:
			if (in == Py_None) {
				ret->info1512 = NULL;
			} else {
				ret->info1512 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1512_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1512 = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(in);
			}
			break;

		case 1513:
			if (in == Py_None) {
				ret->info1513 = NULL;
			} else {
				ret->info1513 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1513_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1513 = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(in);
			}
			break;

		case 1514:
			if (in == Py_None) {
				ret->info1514 = NULL;
			} else {
				ret->info1514 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1514_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1514 = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(in);
			}
			break;

		case 1515:
			if (in == Py_None) {
				ret->info1515 = NULL;
			} else {
				ret->info1515 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1515_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1515 = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(in);
			}
			break;

		case 1516:
			if (in == Py_None) {
				ret->info1516 = NULL;
			} else {
				ret->info1516 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1516_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1516 = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(in);
			}
			break;

		case 1518:
			if (in == Py_None) {
				ret->info1518 = NULL;
			} else {
				ret->info1518 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1518_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1518 = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(in);
			}
			break;

		case 1520:
			if (in == Py_None) {
				ret->info1520 = NULL;
			} else {
				ret->info1520 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1520_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1520 = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(in);
			}
			break;

		case 1521:
			if (in == Py_None) {
				ret->info1521 = NULL;
			} else {
				ret->info1521 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1521_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1521 = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(in);
			}
			break;

		case 1522:
			if (in == Py_None) {
				ret->info1522 = NULL;
			} else {
				ret->info1522 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1522_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1522 = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(in);
			}
			break;

		case 1523:
			if (in == Py_None) {
				ret->info1523 = NULL;
			} else {
				ret->info1523 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1523_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1523 = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(in);
			}
			break;

		case 1524:
			if (in == Py_None) {
				ret->info1524 = NULL;
			} else {
				ret->info1524 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1524_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1524 = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(in);
			}
			break;

		case 1525:
			if (in == Py_None) {
				ret->info1525 = NULL;
			} else {
				ret->info1525 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1525_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1525 = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(in);
			}
			break;

		case 1528:
			if (in == Py_None) {
				ret->info1528 = NULL;
			} else {
				ret->info1528 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1528_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1528 = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(in);
			}
			break;

		case 1529:
			if (in == Py_None) {
				ret->info1529 = NULL;
			} else {
				ret->info1529 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1529_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1529 = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(in);
			}
			break;

		case 1530:
			if (in == Py_None) {
				ret->info1530 = NULL;
			} else {
				ret->info1530 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1530_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1530 = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(in);
			}
			break;

		case 1533:
			if (in == Py_None) {
				ret->info1533 = NULL;
			} else {
				ret->info1533 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1533_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1533 = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(in);
			}
			break;

		case 1534:
			if (in == Py_None) {
				ret->info1534 = NULL;
			} else {
				ret->info1534 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1534_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1534 = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(in);
			}
			break;

		case 1535:
			if (in == Py_None) {
				ret->info1535 = NULL;
			} else {
				ret->info1535 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1535_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1535 = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(in);
			}
			break;

		case 1536:
			if (in == Py_None) {
				ret->info1536 = NULL;
			} else {
				ret->info1536 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1536_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1536 = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(in);
			}
			break;

		case 1537:
			if (in == Py_None) {
				ret->info1537 = NULL;
			} else {
				ret->info1537 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1537_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1537 = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(in);
			}
			break;

		case 1538:
			if (in == Py_None) {
				ret->info1538 = NULL;
			} else {
				ret->info1538 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1538_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1538 = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(in);
			}
			break;

		case 1539:
			if (in == Py_None) {
				ret->info1539 = NULL;
			} else {
				ret->info1539 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1539_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1539 = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(in);
			}
			break;

		case 1540:
			if (in == Py_None) {
				ret->info1540 = NULL;
			} else {
				ret->info1540 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1540_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1540 = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(in);
			}
			break;

		case 1541:
			if (in == Py_None) {
				ret->info1541 = NULL;
			} else {
				ret->info1541 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1541_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1541 = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(in);
			}
			break;

		case 1542:
			if (in == Py_None) {
				ret->info1542 = NULL;
			} else {
				ret->info1542 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1542_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1542 = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(in);
			}
			break;

		case 1543:
			if (in == Py_None) {
				ret->info1543 = NULL;
			} else {
				ret->info1543 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1543_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1543 = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(in);
			}
			break;

		case 1544:
			if (in == Py_None) {
				ret->info1544 = NULL;
			} else {
				ret->info1544 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1544_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1544 = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(in);
			}
			break;

		case 1545:
			if (in == Py_None) {
				ret->info1545 = NULL;
			} else {
				ret->info1545 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1545_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1545 = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(in);
			}
			break;

		case 1546:
			if (in == Py_None) {
				ret->info1546 = NULL;
			} else {
				ret->info1546 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1546_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1546 = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(in);
			}
			break;

		case 1547:
			if (in == Py_None) {
				ret->info1547 = NULL;
			} else {
				ret->info1547 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1547_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1547 = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(in);
			}
			break;

		case 1548:
			if (in == Py_None) {
				ret->info1548 = NULL;
			} else {
				ret->info1548 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1548_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1548 = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(in);
			}
			break;

		case 1549:
			if (in == Py_None) {
				ret->info1549 = NULL;
			} else {
				ret->info1549 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1549_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1549 = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(in);
			}
			break;

		case 1550:
			if (in == Py_None) {
				ret->info1550 = NULL;
			} else {
				ret->info1550 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1550_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1550 = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(in);
			}
			break;

		case 1552:
			if (in == Py_None) {
				ret->info1552 = NULL;
			} else {
				ret->info1552 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1552_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1552 = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(in);
			}
			break;

		case 1553:
			if (in == Py_None) {
				ret->info1553 = NULL;
			} else {
				ret->info1553 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1553_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1553 = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(in);
			}
			break;

		case 1554:
			if (in == Py_None) {
				ret->info1554 = NULL;
			} else {
				ret->info1554 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1554_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1554 = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(in);
			}
			break;

		case 1555:
			if (in == Py_None) {
				ret->info1555 = NULL;
			} else {
				ret->info1555 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1555_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1555 = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(in);
			}
			break;

		case 1556:
			if (in == Py_None) {
				ret->info1556 = NULL;
			} else {
				ret->info1556 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetSrvInfo1556_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->info1556 = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetDiskInfo0_get___disk_offset(PyObject *obj, void *closure)
{
	struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py___disk_offset;
	py___disk_offset = PyInt_FromLong(object->__disk_offset);
	return py___disk_offset;
}

static int py_srvsvc_NetDiskInfo0_set___disk_offset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->__disk_offset = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetDiskInfo0_get___disk_length(PyObject *obj, void *closure)
{
	struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py___disk_length;
	py___disk_length = PyInt_FromLong(object->__disk_length);
	return py___disk_length;
}

static int py_srvsvc_NetDiskInfo0_set___disk_length(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->__disk_length = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetDiskInfo0_get_disk(PyObject *obj, void *closure)
{
	struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_disk;
	if (object->disk == NULL) {
		py_disk = Py_None;
		Py_INCREF(py_disk);
	} else {
		py_disk = PyUnicode_Decode(object->disk, strlen(object->disk), "utf-8", "ignore");
	}
	return py_disk;
}

static int py_srvsvc_NetDiskInfo0_set_disk(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
	if (PyUnicode_Check(value)) {
		object->disk = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
	} else if (PyString_Check(value)) {
		object->disk = 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_srvsvc_NetDiskInfo0_getsetters[] = {
	{ discard_const_p(char, "__disk_offset"), py_srvsvc_NetDiskInfo0_get___disk_offset, py_srvsvc_NetDiskInfo0_set___disk_offset },
	{ discard_const_p(char, "__disk_length"), py_srvsvc_NetDiskInfo0_get___disk_length, py_srvsvc_NetDiskInfo0_set___disk_length },
	{ discard_const_p(char, "disk"), py_srvsvc_NetDiskInfo0_get_disk, py_srvsvc_NetDiskInfo0_set_disk },
	{ NULL }
};

static PyObject *py_srvsvc_NetDiskInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetDiskInfo0, type);
}


static PyTypeObject srvsvc_NetDiskInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetDiskInfo0",
	.tp_getset = py_srvsvc_NetDiskInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetDiskInfo0_new,
};


static PyObject *py_srvsvc_NetDiskInfo_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetDiskInfo_get_disks(PyObject *obj, void *closure)
{
	struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(obj);
	PyObject *py_disks;
	if (object->disks == NULL) {
		py_disks = Py_None;
		Py_INCREF(py_disks);
	} else {
		py_disks = PyList_New(object->count);
		if (py_disks == NULL) {
			return NULL;
		}
		{
			int disks_cntr_1;
			for (disks_cntr_1 = 0; disks_cntr_1 < object->count; disks_cntr_1++) {
				PyObject *py_disks_1;
				py_disks_1 = pytalloc_reference_ex(&srvsvc_NetDiskInfo0_Type, object->disks, &object->disks[disks_cntr_1]);
				PyList_SetItem(py_disks, disks_cntr_1, py_disks_1);
			}
		}
	}
	return py_disks;
}

static int py_srvsvc_NetDiskInfo_set_disks(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->disks);
	if (value == Py_None) {
		object->disks = NULL;
	} else {
		object->disks = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int disks_cntr_1;
			object->disks = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->disks, PyList_GET_SIZE(value));
			if (!object->disks) { return -1;; }
			talloc_set_name_const(object->disks, "ARRAY: object->disks");
			for (disks_cntr_1 = 0; disks_cntr_1 < PyList_GET_SIZE(value); disks_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetDiskInfo0_Type, PyList_GET_ITEM(value, disks_cntr_1), return -1;);
				if (talloc_reference(object->disks, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, disks_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->disks[disks_cntr_1] = *(struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, disks_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetDiskInfo_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetDiskInfo_get_count, py_srvsvc_NetDiskInfo_set_count },
	{ discard_const_p(char, "disks"), py_srvsvc_NetDiskInfo_get_disks, py_srvsvc_NetDiskInfo_set_disks },
	{ NULL }
};

static PyObject *py_srvsvc_NetDiskInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetDiskInfo, type);
}


static PyTypeObject srvsvc_NetDiskInfo_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetDiskInfo",
	.tp_getset = py_srvsvc_NetDiskInfo_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetDiskInfo_new,
};


static PyObject *py_srvsvc_Statistics_get_start(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_start;
	py_start = PyInt_FromLong(object->start);
	return py_start;
}

static int py_srvsvc_Statistics_set_start(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->start = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_fopens(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_fopens;
	py_fopens = PyInt_FromLong(object->fopens);
	return py_fopens;
}

static int py_srvsvc_Statistics_set_fopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->fopens = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_devopens(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_devopens;
	py_devopens = PyInt_FromLong(object->devopens);
	return py_devopens;
}

static int py_srvsvc_Statistics_set_devopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->devopens = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_jobsqueued(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_jobsqueued;
	py_jobsqueued = PyInt_FromLong(object->jobsqueued);
	return py_jobsqueued;
}

static int py_srvsvc_Statistics_set_jobsqueued(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->jobsqueued = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_sopens(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_sopens;
	py_sopens = PyInt_FromLong(object->sopens);
	return py_sopens;
}

static int py_srvsvc_Statistics_set_sopens(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->sopens = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_stimeouts(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_stimeouts;
	py_stimeouts = PyInt_FromLong(object->stimeouts);
	return py_stimeouts;
}

static int py_srvsvc_Statistics_set_stimeouts(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->stimeouts = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_serrorout(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_serrorout;
	py_serrorout = PyInt_FromLong(object->serrorout);
	return py_serrorout;
}

static int py_srvsvc_Statistics_set_serrorout(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->serrorout = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_pwerrors(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_pwerrors;
	py_pwerrors = PyInt_FromLong(object->pwerrors);
	return py_pwerrors;
}

static int py_srvsvc_Statistics_set_pwerrors(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->pwerrors = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_permerrors(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_permerrors;
	py_permerrors = PyInt_FromLong(object->permerrors);
	return py_permerrors;
}

static int py_srvsvc_Statistics_set_permerrors(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->permerrors = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_syserrors(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_syserrors;
	py_syserrors = PyInt_FromLong(object->syserrors);
	return py_syserrors;
}

static int py_srvsvc_Statistics_set_syserrors(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->syserrors = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_bytessent_low(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_bytessent_low;
	py_bytessent_low = PyInt_FromLong(object->bytessent_low);
	return py_bytessent_low;
}

static int py_srvsvc_Statistics_set_bytessent_low(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->bytessent_low = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_bytessent_high(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_bytessent_high;
	py_bytessent_high = PyInt_FromLong(object->bytessent_high);
	return py_bytessent_high;
}

static int py_srvsvc_Statistics_set_bytessent_high(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->bytessent_high = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_bytesrcvd_low(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_bytesrcvd_low;
	py_bytesrcvd_low = PyInt_FromLong(object->bytesrcvd_low);
	return py_bytesrcvd_low;
}

static int py_srvsvc_Statistics_set_bytesrcvd_low(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->bytesrcvd_low = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_bytesrcvd_high(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_bytesrcvd_high;
	py_bytesrcvd_high = PyInt_FromLong(object->bytesrcvd_high);
	return py_bytesrcvd_high;
}

static int py_srvsvc_Statistics_set_bytesrcvd_high(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->bytesrcvd_high = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_avresponse(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_avresponse;
	py_avresponse = PyInt_FromLong(object->avresponse);
	return py_avresponse;
}

static int py_srvsvc_Statistics_set_avresponse(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->avresponse = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_reqbufneed(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_reqbufneed;
	py_reqbufneed = PyInt_FromLong(object->reqbufneed);
	return py_reqbufneed;
}

static int py_srvsvc_Statistics_set_reqbufneed(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->reqbufneed = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_Statistics_get_bigbufneed(PyObject *obj, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
	PyObject *py_bigbufneed;
	py_bigbufneed = PyInt_FromLong(object->bigbufneed);
	return py_bigbufneed;
}

static int py_srvsvc_Statistics_set_bigbufneed(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->bigbufneed = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_Statistics_getsetters[] = {
	{ discard_const_p(char, "start"), py_srvsvc_Statistics_get_start, py_srvsvc_Statistics_set_start },
	{ discard_const_p(char, "fopens"), py_srvsvc_Statistics_get_fopens, py_srvsvc_Statistics_set_fopens },
	{ discard_const_p(char, "devopens"), py_srvsvc_Statistics_get_devopens, py_srvsvc_Statistics_set_devopens },
	{ discard_const_p(char, "jobsqueued"), py_srvsvc_Statistics_get_jobsqueued, py_srvsvc_Statistics_set_jobsqueued },
	{ discard_const_p(char, "sopens"), py_srvsvc_Statistics_get_sopens, py_srvsvc_Statistics_set_sopens },
	{ discard_const_p(char, "stimeouts"), py_srvsvc_Statistics_get_stimeouts, py_srvsvc_Statistics_set_stimeouts },
	{ discard_const_p(char, "serrorout"), py_srvsvc_Statistics_get_serrorout, py_srvsvc_Statistics_set_serrorout },
	{ discard_const_p(char, "pwerrors"), py_srvsvc_Statistics_get_pwerrors, py_srvsvc_Statistics_set_pwerrors },
	{ discard_const_p(char, "permerrors"), py_srvsvc_Statistics_get_permerrors, py_srvsvc_Statistics_set_permerrors },
	{ discard_const_p(char, "syserrors"), py_srvsvc_Statistics_get_syserrors, py_srvsvc_Statistics_set_syserrors },
	{ discard_const_p(char, "bytessent_low"), py_srvsvc_Statistics_get_bytessent_low, py_srvsvc_Statistics_set_bytessent_low },
	{ discard_const_p(char, "bytessent_high"), py_srvsvc_Statistics_get_bytessent_high, py_srvsvc_Statistics_set_bytessent_high },
	{ discard_const_p(char, "bytesrcvd_low"), py_srvsvc_Statistics_get_bytesrcvd_low, py_srvsvc_Statistics_set_bytesrcvd_low },
	{ discard_const_p(char, "bytesrcvd_high"), py_srvsvc_Statistics_get_bytesrcvd_high, py_srvsvc_Statistics_set_bytesrcvd_high },
	{ discard_const_p(char, "avresponse"), py_srvsvc_Statistics_get_avresponse, py_srvsvc_Statistics_set_avresponse },
	{ discard_const_p(char, "reqbufneed"), py_srvsvc_Statistics_get_reqbufneed, py_srvsvc_Statistics_set_reqbufneed },
	{ discard_const_p(char, "bigbufneed"), py_srvsvc_Statistics_get_bigbufneed, py_srvsvc_Statistics_set_bigbufneed },
	{ NULL }
};

static PyObject *py_srvsvc_Statistics_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_Statistics, type);
}


static PyTypeObject srvsvc_Statistics_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.Statistics",
	.tp_getset = py_srvsvc_Statistics_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_Statistics_new,
};


static PyObject *py_srvsvc_NetTransportInfo0_get_vcs(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_vcs;
	py_vcs = PyInt_FromLong(object->vcs);
	return py_vcs;
}

static int py_srvsvc_NetTransportInfo0_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->vcs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo0_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetTransportInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetTransportInfo0_get_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_addr;
	if (object->addr == NULL) {
		py_addr = Py_None;
		Py_INCREF(py_addr);
	} else {
		py_addr = PyList_New(object->addr_len);
		if (py_addr == NULL) {
			return NULL;
		}
		{
			int addr_cntr_1;
			for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
				PyObject *py_addr_1;
				py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
				PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
			}
		}
	}
	return py_addr;
}

static int py_srvsvc_NetTransportInfo0_set_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
	if (value == Py_None) {
		object->addr = NULL;
	} else {
		object->addr = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int addr_cntr_1;
			object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
			if (!object->addr) { return -1;; }
			talloc_set_name_const(object->addr, "ARRAY: object->addr");
			for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
				PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
				object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
			}
		}
	}
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo0_get_addr_len(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_addr_len;
	py_addr_len = PyInt_FromLong(object->addr_len);
	return py_addr_len;
}

static int py_srvsvc_NetTransportInfo0_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->addr_len = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo0_get_net_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_net_addr;
	if (object->net_addr == NULL) {
		py_net_addr = Py_None;
		Py_INCREF(py_net_addr);
	} else {
		if (object->net_addr == NULL) {
			py_net_addr = Py_None;
			Py_INCREF(py_net_addr);
		} else {
			py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
		}
	}
	return py_net_addr;
}

static int py_srvsvc_NetTransportInfo0_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->net_addr = NULL;
	} else {
		object->net_addr = NULL;
		if (PyUnicode_Check(value)) {
			object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->net_addr = 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_srvsvc_NetTransportInfo0_getsetters[] = {
	{ discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo0_get_vcs, py_srvsvc_NetTransportInfo0_set_vcs },
	{ discard_const_p(char, "name"), py_srvsvc_NetTransportInfo0_get_name, py_srvsvc_NetTransportInfo0_set_name },
	{ discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo0_get_addr, py_srvsvc_NetTransportInfo0_set_addr },
	{ discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo0_get_addr_len, py_srvsvc_NetTransportInfo0_set_addr_len },
	{ discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo0_get_net_addr, py_srvsvc_NetTransportInfo0_set_net_addr },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportInfo0, type);
}


static PyTypeObject srvsvc_NetTransportInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportInfo0",
	.tp_getset = py_srvsvc_NetTransportInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportInfo0_new,
};


static PyObject *py_srvsvc_NetTransportCtr0_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetTransportCtr0_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetTransportCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetTransportCtr0_get_count, py_srvsvc_NetTransportCtr0_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetTransportCtr0_get_array, py_srvsvc_NetTransportCtr0_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportCtr0, type);
}


static PyTypeObject srvsvc_NetTransportCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportCtr0",
	.tp_getset = py_srvsvc_NetTransportCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportCtr0_new,
};


static PyObject *py_srvsvc_NetTransportInfo1_get_vcs(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_vcs;
	py_vcs = PyInt_FromLong(object->vcs);
	return py_vcs;
}

static int py_srvsvc_NetTransportInfo1_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->vcs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo1_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetTransportInfo1_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetTransportInfo1_get_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_addr;
	if (object->addr == NULL) {
		py_addr = Py_None;
		Py_INCREF(py_addr);
	} else {
		py_addr = PyList_New(object->addr_len);
		if (py_addr == NULL) {
			return NULL;
		}
		{
			int addr_cntr_1;
			for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
				PyObject *py_addr_1;
				py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
				PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
			}
		}
	}
	return py_addr;
}

static int py_srvsvc_NetTransportInfo1_set_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
	if (value == Py_None) {
		object->addr = NULL;
	} else {
		object->addr = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int addr_cntr_1;
			object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
			if (!object->addr) { return -1;; }
			talloc_set_name_const(object->addr, "ARRAY: object->addr");
			for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
				PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
				object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
			}
		}
	}
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo1_get_addr_len(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_addr_len;
	py_addr_len = PyInt_FromLong(object->addr_len);
	return py_addr_len;
}

static int py_srvsvc_NetTransportInfo1_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->addr_len = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo1_get_net_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_net_addr;
	if (object->net_addr == NULL) {
		py_net_addr = Py_None;
		Py_INCREF(py_net_addr);
	} else {
		if (object->net_addr == NULL) {
			py_net_addr = Py_None;
			Py_INCREF(py_net_addr);
		} else {
			py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
		}
	}
	return py_net_addr;
}

static int py_srvsvc_NetTransportInfo1_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->net_addr = NULL;
	} else {
		object->net_addr = NULL;
		if (PyUnicode_Check(value)) {
			object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->net_addr = 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_srvsvc_NetTransportInfo1_get_domain(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_domain;
	if (object->domain == NULL) {
		py_domain = Py_None;
		Py_INCREF(py_domain);
	} else {
		if (object->domain == NULL) {
			py_domain = Py_None;
			Py_INCREF(py_domain);
		} else {
			py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
		}
	}
	return py_domain;
}

static int py_srvsvc_NetTransportInfo1_set_domain(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->domain = NULL;
	} else {
		object->domain = NULL;
		if (PyUnicode_Check(value)) {
			object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->domain = 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_srvsvc_NetTransportInfo1_getsetters[] = {
	{ discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo1_get_vcs, py_srvsvc_NetTransportInfo1_set_vcs },
	{ discard_const_p(char, "name"), py_srvsvc_NetTransportInfo1_get_name, py_srvsvc_NetTransportInfo1_set_name },
	{ discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo1_get_addr, py_srvsvc_NetTransportInfo1_set_addr },
	{ discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo1_get_addr_len, py_srvsvc_NetTransportInfo1_set_addr_len },
	{ discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo1_get_net_addr, py_srvsvc_NetTransportInfo1_set_net_addr },
	{ discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo1_get_domain, py_srvsvc_NetTransportInfo1_set_domain },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportInfo1, type);
}


static PyTypeObject srvsvc_NetTransportInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportInfo1",
	.tp_getset = py_srvsvc_NetTransportInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportInfo1_new,
};


static PyObject *py_srvsvc_NetTransportCtr1_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetTransportCtr1_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetTransportCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetTransportInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetTransportCtr1_get_count, py_srvsvc_NetTransportCtr1_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetTransportCtr1_get_array, py_srvsvc_NetTransportCtr1_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportCtr1, type);
}


static PyTypeObject srvsvc_NetTransportCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportCtr1",
	.tp_getset = py_srvsvc_NetTransportCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportCtr1_new,
};


static PyObject *py_srvsvc_NetTransportInfo2_get_vcs(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_vcs;
	py_vcs = PyInt_FromLong(object->vcs);
	return py_vcs;
}

static int py_srvsvc_NetTransportInfo2_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->vcs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo2_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetTransportInfo2_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetTransportInfo2_get_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_addr;
	if (object->addr == NULL) {
		py_addr = Py_None;
		Py_INCREF(py_addr);
	} else {
		py_addr = PyList_New(object->addr_len);
		if (py_addr == NULL) {
			return NULL;
		}
		{
			int addr_cntr_1;
			for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
				PyObject *py_addr_1;
				py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
				PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
			}
		}
	}
	return py_addr;
}

static int py_srvsvc_NetTransportInfo2_set_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
	if (value == Py_None) {
		object->addr = NULL;
	} else {
		object->addr = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int addr_cntr_1;
			object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
			if (!object->addr) { return -1;; }
			talloc_set_name_const(object->addr, "ARRAY: object->addr");
			for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
				PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
				object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
			}
		}
	}
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo2_get_addr_len(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_addr_len;
	py_addr_len = PyInt_FromLong(object->addr_len);
	return py_addr_len;
}

static int py_srvsvc_NetTransportInfo2_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->addr_len = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo2_get_net_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_net_addr;
	if (object->net_addr == NULL) {
		py_net_addr = Py_None;
		Py_INCREF(py_net_addr);
	} else {
		if (object->net_addr == NULL) {
			py_net_addr = Py_None;
			Py_INCREF(py_net_addr);
		} else {
			py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
		}
	}
	return py_net_addr;
}

static int py_srvsvc_NetTransportInfo2_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->net_addr = NULL;
	} else {
		object->net_addr = NULL;
		if (PyUnicode_Check(value)) {
			object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->net_addr = 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_srvsvc_NetTransportInfo2_get_domain(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_domain;
	if (object->domain == NULL) {
		py_domain = Py_None;
		Py_INCREF(py_domain);
	} else {
		if (object->domain == NULL) {
			py_domain = Py_None;
			Py_INCREF(py_domain);
		} else {
			py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
		}
	}
	return py_domain;
}

static int py_srvsvc_NetTransportInfo2_set_domain(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->domain = NULL;
	} else {
		object->domain = NULL;
		if (PyUnicode_Check(value)) {
			object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->domain = 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_srvsvc_NetTransportInfo2_get_unknown(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown;
	py_unknown = PyInt_FromLong(object->unknown);
	return py_unknown;
}

static int py_srvsvc_NetTransportInfo2_set_unknown(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->unknown = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportInfo2_getsetters[] = {
	{ discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo2_get_vcs, py_srvsvc_NetTransportInfo2_set_vcs },
	{ discard_const_p(char, "name"), py_srvsvc_NetTransportInfo2_get_name, py_srvsvc_NetTransportInfo2_set_name },
	{ discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo2_get_addr, py_srvsvc_NetTransportInfo2_set_addr },
	{ discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo2_get_addr_len, py_srvsvc_NetTransportInfo2_set_addr_len },
	{ discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo2_get_net_addr, py_srvsvc_NetTransportInfo2_set_net_addr },
	{ discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo2_get_domain, py_srvsvc_NetTransportInfo2_set_domain },
	{ discard_const_p(char, "unknown"), py_srvsvc_NetTransportInfo2_get_unknown, py_srvsvc_NetTransportInfo2_set_unknown },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportInfo2, type);
}


static PyTypeObject srvsvc_NetTransportInfo2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportInfo2",
	.tp_getset = py_srvsvc_NetTransportInfo2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportInfo2_new,
};


static PyObject *py_srvsvc_NetTransportCtr2_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetTransportCtr2_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo2_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetTransportCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetTransportInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportCtr2_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetTransportCtr2_get_count, py_srvsvc_NetTransportCtr2_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetTransportCtr2_get_array, py_srvsvc_NetTransportCtr2_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportCtr2, type);
}


static PyTypeObject srvsvc_NetTransportCtr2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportCtr2",
	.tp_getset = py_srvsvc_NetTransportCtr2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportCtr2_new,
};


static PyObject *py_srvsvc_NetTransportInfo3_get_vcs(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_vcs;
	py_vcs = PyInt_FromLong(object->vcs);
	return py_vcs;
}

static int py_srvsvc_NetTransportInfo3_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->vcs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo3_get_name(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_name;
	if (object->name == NULL) {
		py_name = Py_None;
		Py_INCREF(py_name);
	} else {
		if (object->name == NULL) {
			py_name = Py_None;
			Py_INCREF(py_name);
		} else {
			py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
		}
	}
	return py_name;
}

static int py_srvsvc_NetTransportInfo3_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->name = NULL;
	} else {
		object->name = NULL;
		if (PyUnicode_Check(value)) {
			object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->name = 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_srvsvc_NetTransportInfo3_get_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_addr;
	if (object->addr == NULL) {
		py_addr = Py_None;
		Py_INCREF(py_addr);
	} else {
		py_addr = PyList_New(object->addr_len);
		if (py_addr == NULL) {
			return NULL;
		}
		{
			int addr_cntr_1;
			for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
				PyObject *py_addr_1;
				py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
				PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
			}
		}
	}
	return py_addr;
}

static int py_srvsvc_NetTransportInfo3_set_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
	if (value == Py_None) {
		object->addr = NULL;
	} else {
		object->addr = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int addr_cntr_1;
			object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
			if (!object->addr) { return -1;; }
			talloc_set_name_const(object->addr, "ARRAY: object->addr");
			for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
				PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
				object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
			}
		}
	}
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo3_get_addr_len(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_addr_len;
	py_addr_len = PyInt_FromLong(object->addr_len);
	return py_addr_len;
}

static int py_srvsvc_NetTransportInfo3_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->addr_len = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo3_get_net_addr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_net_addr;
	if (object->net_addr == NULL) {
		py_net_addr = Py_None;
		Py_INCREF(py_net_addr);
	} else {
		if (object->net_addr == NULL) {
			py_net_addr = Py_None;
			Py_INCREF(py_net_addr);
		} else {
			py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
		}
	}
	return py_net_addr;
}

static int py_srvsvc_NetTransportInfo3_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->net_addr = NULL;
	} else {
		object->net_addr = NULL;
		if (PyUnicode_Check(value)) {
			object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->net_addr = 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_srvsvc_NetTransportInfo3_get_domain(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_domain;
	if (object->domain == NULL) {
		py_domain = Py_None;
		Py_INCREF(py_domain);
	} else {
		if (object->domain == NULL) {
			py_domain = Py_None;
			Py_INCREF(py_domain);
		} else {
			py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
		}
	}
	return py_domain;
}

static int py_srvsvc_NetTransportInfo3_set_domain(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->domain = NULL;
	} else {
		object->domain = NULL;
		if (PyUnicode_Check(value)) {
			object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->domain = 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_srvsvc_NetTransportInfo3_get_unknown1(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown1;
	py_unknown1 = PyInt_FromLong(object->unknown1);
	return py_unknown1;
}

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

static PyObject *py_srvsvc_NetTransportInfo3_get_unknown2(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown2;
	py_unknown2 = PyInt_FromLong(object->unknown2);
	return py_unknown2;
}

static int py_srvsvc_NetTransportInfo3_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->unknown2 = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetTransportInfo3_get_unknown3(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown3;
	py_unknown3 = PyList_New(256);
	if (py_unknown3 == NULL) {
		return NULL;
	}
	{
		int unknown3_cntr_0;
		for (unknown3_cntr_0 = 0; unknown3_cntr_0 < 256; unknown3_cntr_0++) {
			PyObject *py_unknown3_0;
			py_unknown3_0 = PyInt_FromLong(object->unknown3[unknown3_cntr_0]);
			PyList_SetItem(py_unknown3, unknown3_cntr_0, py_unknown3_0);
		}
	}
	return py_unknown3;
}

static int py_srvsvc_NetTransportInfo3_set_unknown3(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int unknown3_cntr_0;
		for (unknown3_cntr_0 = 0; unknown3_cntr_0 < PyList_GET_SIZE(value); unknown3_cntr_0++) {
			PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, unknown3_cntr_0), return -1;);
			object->unknown3[unknown3_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, unknown3_cntr_0));
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportInfo3_getsetters[] = {
	{ discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo3_get_vcs, py_srvsvc_NetTransportInfo3_set_vcs },
	{ discard_const_p(char, "name"), py_srvsvc_NetTransportInfo3_get_name, py_srvsvc_NetTransportInfo3_set_name },
	{ discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo3_get_addr, py_srvsvc_NetTransportInfo3_set_addr },
	{ discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo3_get_addr_len, py_srvsvc_NetTransportInfo3_set_addr_len },
	{ discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo3_get_net_addr, py_srvsvc_NetTransportInfo3_set_net_addr },
	{ discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo3_get_domain, py_srvsvc_NetTransportInfo3_set_domain },
	{ discard_const_p(char, "unknown1"), py_srvsvc_NetTransportInfo3_get_unknown1, py_srvsvc_NetTransportInfo3_set_unknown1 },
	{ discard_const_p(char, "unknown2"), py_srvsvc_NetTransportInfo3_get_unknown2, py_srvsvc_NetTransportInfo3_set_unknown2 },
	{ discard_const_p(char, "unknown3"), py_srvsvc_NetTransportInfo3_get_unknown3, py_srvsvc_NetTransportInfo3_set_unknown3 },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportInfo3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportInfo3, type);
}


static PyTypeObject srvsvc_NetTransportInfo3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportInfo3",
	.tp_getset = py_srvsvc_NetTransportInfo3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportInfo3_new,
};


static PyObject *py_srvsvc_NetTransportCtr3_get_count(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(obj);
	PyObject *py_count;
	py_count = PyInt_FromLong(object->count);
	return py_count;
}

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

static PyObject *py_srvsvc_NetTransportCtr3_get_array(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(obj);
	PyObject *py_array;
	if (object->array == NULL) {
		py_array = Py_None;
		Py_INCREF(py_array);
	} else {
		py_array = PyList_New(object->count);
		if (py_array == NULL) {
			return NULL;
		}
		{
			int array_cntr_1;
			for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
				PyObject *py_array_1;
				py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo3_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_srvsvc_NetTransportCtr3_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
	if (value == Py_None) {
		object->array = NULL;
	} else {
		object->array = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int array_cntr_1;
			object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
			if (!object->array) { return -1;; }
			talloc_set_name_const(object->array, "ARRAY: object->array");
			for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
				PY_CHECK_TYPE(&srvsvc_NetTransportInfo3_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
				if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportCtr3_getsetters[] = {
	{ discard_const_p(char, "count"), py_srvsvc_NetTransportCtr3_get_count, py_srvsvc_NetTransportCtr3_set_count },
	{ discard_const_p(char, "array"), py_srvsvc_NetTransportCtr3_get_array, py_srvsvc_NetTransportCtr3_set_array },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportCtr3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportCtr3, type);
}


static PyTypeObject srvsvc_NetTransportCtr3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportCtr3",
	.tp_getset = py_srvsvc_NetTransportCtr3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportCtr3_new,
};

PyObject *py_import_srvsvc_NetTransportCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetTransportCtr *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			if (in->ctr0 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr0_Type, in->ctr0, in->ctr0);
			}
			return ret;

		case 1:
			if (in->ctr1 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr1_Type, in->ctr1, in->ctr1);
			}
			return ret;

		case 2:
			if (in->ctr2 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr2_Type, in->ctr2, in->ctr2);
			}
			return ret;

		case 3:
			if (in->ctr3 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr3_Type, in->ctr3, in->ctr3);
			}
			return ret;

		default:
			ret = Py_None;
			Py_INCREF(ret);
			return ret;

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

union srvsvc_NetTransportCtr *py_export_srvsvc_NetTransportCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetTransportCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetTransportCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetTransportCtr0_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr0 = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetTransportCtr1_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr1 = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->ctr2 = NULL;
			} else {
				ret->ctr2 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetTransportCtr2_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr2 = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(in);
			}
			break;

		case 3:
			if (in == Py_None) {
				ret->ctr3 = NULL;
			} else {
				ret->ctr3 = NULL;
				PY_CHECK_TYPE(&srvsvc_NetTransportCtr3_Type, in, talloc_free(ret); return NULL;);
				if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
					PyErr_NoMemory();
					talloc_free(ret); return NULL;
				}
				ret->ctr3 = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_srvsvc_NetTransportInfoCtr_get_level(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyInt_FromLong(object->level);
	return py_level;
}

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

static PyObject *py_srvsvc_NetTransportInfoCtr_get_ctr(PyObject *obj, void *closure)
{
	struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(obj);
	PyObject *py_ctr;
	py_ctr = py_import_srvsvc_NetTransportCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	return py_ctr;
}

static int py_srvsvc_NetTransportInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_obj);
	{
		union srvsvc_NetTransportCtr *ctr_switch_0;
		ctr_switch_0 = py_export_srvsvc_NetTransportCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
		if (ctr_switch_0 == NULL) {
			return -1;
		}
		object->ctr = *ctr_switch_0;
	}
	return 0;
}

static PyGetSetDef py_srvsvc_NetTransportInfoCtr_getsetters[] = {
	{ discard_const_p(char, "level"), py_srvsvc_NetTransportInfoCtr_get_level, py_srvsvc_NetTransportInfoCtr_set_level },
	{ discard_const_p(char, "ctr"), py_srvsvc_NetTransportInfoCtr_get_ctr, py_srvsvc_NetTransportInfoCtr_set_ctr },
	{ NULL }
};

static PyObject *py_srvsvc_NetTransportInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetTransportInfoCtr, type);
}


static PyTypeObject srvsvc_NetTransportInfoCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetTransportInfoCtr",
	.tp_getset = py_srvsvc_NetTransportInfoCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetTransportInfoCtr_new,
};


static PyObject *py_srvsvc_NetRemoteTODInfo_get_elapsed(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_elapsed;
	py_elapsed = PyInt_FromLong(object->elapsed);
	return py_elapsed;
}

static int py_srvsvc_NetRemoteTODInfo_set_elapsed(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->elapsed = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_msecs(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_msecs;
	py_msecs = PyInt_FromLong(object->msecs);
	return py_msecs;
}

static int py_srvsvc_NetRemoteTODInfo_set_msecs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->msecs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_hours(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_hours;
	py_hours = PyInt_FromLong(object->hours);
	return py_hours;
}

static int py_srvsvc_NetRemoteTODInfo_set_hours(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->hours = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_mins(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_mins;
	py_mins = PyInt_FromLong(object->mins);
	return py_mins;
}

static int py_srvsvc_NetRemoteTODInfo_set_mins(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->mins = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_secs(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_secs;
	py_secs = PyInt_FromLong(object->secs);
	return py_secs;
}

static int py_srvsvc_NetRemoteTODInfo_set_secs(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->secs = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_hunds(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_hunds;
	py_hunds = PyInt_FromLong(object->hunds);
	return py_hunds;
}

static int py_srvsvc_NetRemoteTODInfo_set_hunds(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->hunds = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_timezone(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_timezone;
	py_timezone = PyInt_FromLong(object->timezone);
	return py_timezone;
}

static int py_srvsvc_NetRemoteTODInfo_set_timezone(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->timezone = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_tinterval(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_tinterval;
	py_tinterval = PyInt_FromLong(object->tinterval);
	return py_tinterval;
}

static int py_srvsvc_NetRemoteTODInfo_set_tinterval(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->tinterval = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_day(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_day;
	py_day = PyInt_FromLong(object->day);
	return py_day;
}

static int py_srvsvc_NetRemoteTODInfo_set_day(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->day = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_month(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_month;
	py_month = PyInt_FromLong(object->month);
	return py_month;
}

static int py_srvsvc_NetRemoteTODInfo_set_month(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->month = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_year(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_year;
	py_year = PyInt_FromLong(object->year);
	return py_year;
}

static int py_srvsvc_NetRemoteTODInfo_set_year(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->year = PyInt_AsLong(value);
	return 0;
}

static PyObject *py_srvsvc_NetRemoteTODInfo_get_weekday(PyObject *obj, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
	PyObject *py_weekday;
	py_weekday = PyInt_FromLong(object->weekday);
	return py_weekday;
}

static int py_srvsvc_NetRemoteTODInfo_set_weekday(PyObject *py_obj, PyObject *value, void *closure)
{
	struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
	object->weekday = PyInt_AsLong(value);
	return 0;
}

static PyGetSetDef py_srvsvc_NetRemoteTODInfo_getsetters[] = {
	{ discard_const_p(char, "elapsed"), py_srvsvc_NetRemoteTODInfo_get_elapsed, py_srvsvc_NetRemoteTODInfo_set_elapsed },
	{ discard_const_p(char, "msecs"), py_srvsvc_NetRemoteTODInfo_get_msecs, py_srvsvc_NetRemoteTODInfo_set_msecs },
	{ discard_const_p(char, "hours"), py_srvsvc_NetRemoteTODInfo_get_hours, py_srvsvc_NetRemoteTODInfo_set_hours },
	{ discard_const_p(char, "mins"), py_srvsvc_NetRemoteTODInfo_get_mins, py_srvsvc_NetRemoteTODInfo_set_mins },
	{ discard_const_p(char, "secs"), py_srvsvc_NetRemoteTODInfo_get_secs, py_srvsvc_NetRemoteTODInfo_set_secs },
	{ discard_const_p(char, "hunds"), py_srvsvc_NetRemoteTODInfo_get_hunds, py_srvsvc_NetRemoteTODInfo_set_hunds },
	{ discard_const_p(char, "timezone"), py_srvsvc_NetRemoteTODInfo_get_timezone, py_srvsvc_NetRemoteTODInfo_set_timezone },
	{ discard_const_p(char, "tinterval"), py_srvsvc_NetRemoteTODInfo_get_tinterval, py_srvsvc_NetRemoteTODInfo_set_tinterval },
	{ discard_const_p(char, "day"), py_srvsvc_NetRemoteTODInfo_get_day, py_srvsvc_NetRemoteTODInfo_set_day },
	{ discard_const_p(char, "month"), py_srvsvc_NetRemoteTODInfo_get_month, py_srvsvc_NetRemoteTODInfo_set_month },
	{ discard_const_p(char, "year"), py_srvsvc_NetRemoteTODInfo_get_year, py_srvsvc_NetRemoteTODInfo_set_year },
	{ discard_const_p(char, "weekday"), py_srvsvc_NetRemoteTODInfo_get_weekday, py_srvsvc_NetRemoteTODInfo_set_weekday },
	{ NULL }
};

static PyObject *py_srvsvc_NetRemoteTODInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct srvsvc_NetRemoteTODInfo, type);
}


static PyTypeObject srvsvc_NetRemoteTODInfo_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.NetRemoteTODInfo",
	.tp_getset = py_srvsvc_NetRemoteTODInfo_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_srvsvc_NetRemoteTODInfo_new,
};

PyObject *py_import_srvsvc_NetTransportInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetTransportInfo *in)
{
	PyObject *ret;

	switch (level) {
		case 0:
			ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo0_Type, mem_ctx, &in->info0);
			return ret;

		case 1:
			ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo1_Type, mem_ctx, &in->info1);
			return ret;

		case 2:
			ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo2_Type, mem_ctx, &in->info2);
			return ret;

		case 3:
			ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo3_Type, mem_ctx, &in->info3);
			return ret;

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

union srvsvc_NetTransportInfo *py_export_srvsvc_NetTransportInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union srvsvc_NetTransportInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetTransportInfo);
	switch (level) {
		case 0:
			PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, in, talloc_free(ret); return NULL;);
			if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
				PyErr_NoMemory();
				talloc_free(ret); return NULL;
			}
			ret->info0 = *(struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(in);
			break;

		case 1:
			PY_CHECK_TYPE(&srvsvc_NetTransportInfo1_Type, in, talloc_free(ret); return NULL;);
			if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
				PyErr_NoMemory();
				talloc_free(ret); return NULL;
			}
			ret->info1 = *(struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(in);
			break;

		case 2:
			PY_CHECK_TYPE(&srvsvc_NetTransportInfo2_Type, in, talloc_free(ret); return NULL;);
			if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
				PyErr_NoMemory();
				talloc_free(ret); return NULL;
			}
			ret->info2 = *(struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(in);
			break;

		case 3:
			PY_CHECK_TYPE(&srvsvc_NetTransportInfo3_Type, in, talloc_free(ret); return NULL;);
			if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
				PyErr_NoMemory();
				talloc_free(ret); return NULL;
			}
			ret->info3 = *(struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(in);
			break;

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

	return ret;
}


static bool pack_py_srvsvc_NetCharDevEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetCharDevEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetCharDevInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetCharDevEnum_args_out(struct srvsvc_NetCharDevEnum *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetCharDevInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetCharDevGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevGetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_device_name;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_unc", "device_name", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name, &py_level)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_device_name)) {
		r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_device_name)) {
		r->in.device_name = PyString_AS_STRING(py_device_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->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_srvsvc_NetCharDevGetInfo_args_out(struct srvsvc_NetCharDevGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_srvsvc_NetCharDevInfo(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_srvsvc_NetCharDevControl_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevControl *r)
{
	PyObject *py_server_unc;
	PyObject *py_device_name;
	PyObject *py_opcode;
	const char *kwnames[] = {
		"server_unc", "device_name", "opcode", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevControl", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name, &py_opcode)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_device_name)) {
		r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_device_name)) {
		r->in.device_name = PyString_AS_STRING(py_device_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_opcode, return false;);
	r->in.opcode = PyInt_AsLong(py_opcode);
	return true;
}

static PyObject *unpack_py_srvsvc_NetCharDevControl_args_out(struct srvsvc_NetCharDevControl *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_srvsvc_NetCharDevQEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_user;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "user", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetCharDevQEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_user, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_user == Py_None) {
		r->in.user = NULL;
	} else {
		r->in.user = NULL;
		if (PyUnicode_Check(py_user)) {
			r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
		} else if (PyString_Check(py_user)) {
			r->in.user = PyString_AS_STRING(py_user);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
			return false;
		}
	}
	r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetCharDevQInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetCharDevQEnum_args_out(struct srvsvc_NetCharDevQEnum *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetCharDevQInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetCharDevQGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQGetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_queue_name;
	PyObject *py_user;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_unc", "queue_name", "user", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetCharDevQGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_user, &py_level)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(py_queue_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_user)) {
		r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
	} else if (PyString_Check(py_user)) {
		r->in.user = PyString_AS_STRING(py_user);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->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_srvsvc_NetCharDevQGetInfo_args_out(struct srvsvc_NetCharDevQGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_srvsvc_NetCharDevQInfo(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_srvsvc_NetCharDevQSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQSetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_queue_name;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_parm_error;
	const char *kwnames[] = {
		"server_unc", "queue_name", "level", "info", "parm_error", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetCharDevQSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_level, &py_info, &py_parm_error)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(py_queue_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	{
		union srvsvc_NetCharDevQInfo *info_switch_0;
		info_switch_0 = py_export_srvsvc_NetCharDevQInfo(r, r->in.level, py_info);
		if (info_switch_0 == NULL) {
			return false;
		}
		r->in.info = *info_switch_0;
	}
	if (py_parm_error == Py_None) {
		r->in.parm_error = NULL;
	} else {
		r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
		*r->in.parm_error = PyInt_AsLong(py_parm_error);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetCharDevQSetInfo_args_out(struct srvsvc_NetCharDevQSetInfo *r)
{
	PyObject *result;
	PyObject *py_parm_error;
	if (r->out.parm_error == NULL) {
		py_parm_error = Py_None;
		Py_INCREF(py_parm_error);
	} else {
		py_parm_error = PyInt_FromLong(*r->out.parm_error);
	}
	result = py_parm_error;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetCharDevQPurge_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQPurge *r)
{
	PyObject *py_server_unc;
	PyObject *py_queue_name;
	const char *kwnames[] = {
		"server_unc", "queue_name", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetCharDevQPurge", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(py_queue_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
		return false;
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetCharDevQPurge_args_out(struct srvsvc_NetCharDevQPurge *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_srvsvc_NetCharDevQPurgeSelf_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQPurgeSelf *r)
{
	PyObject *py_server_unc;
	PyObject *py_queue_name;
	PyObject *py_computer_name;
	const char *kwnames[] = {
		"server_unc", "queue_name", "computer_name", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevQPurgeSelf", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_computer_name)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_queue_name)) {
		r->in.queue_name = PyString_AS_STRING(py_queue_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_computer_name)) {
		r->in.computer_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_computer_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_computer_name)) {
		r->in.computer_name = PyString_AS_STRING(py_computer_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_computer_name)->tp_name);
		return false;
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetCharDevQPurgeSelf_args_out(struct srvsvc_NetCharDevQPurgeSelf *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_srvsvc_NetConnEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetConnEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_path;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "path", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetConnEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_path == Py_None) {
		r->in.path = NULL;
	} else {
		r->in.path = NULL;
		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.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetConnInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetConnEnum_args_out(struct srvsvc_NetConnEnum *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetConnInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetFileEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_path;
	PyObject *py_user;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "path", "user", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetFileEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_user, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_path == Py_None) {
		r->in.path = NULL;
	} else {
		r->in.path = NULL;
		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;
		}
	}
	if (py_user == Py_None) {
		r->in.user = NULL;
	} else {
		r->in.user = NULL;
		if (PyUnicode_Check(py_user)) {
			r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
		} else if (PyString_Check(py_user)) {
			r->in.user = PyString_AS_STRING(py_user);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
			return false;
		}
	}
	r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetFileInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetFileEnum_args_out(struct srvsvc_NetFileEnum *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetFileInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetFileGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileGetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_fid;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_unc", "fid", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetFileGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_fid, &py_level)) {
		return false;
	}

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

static PyObject *unpack_py_srvsvc_NetFileGetInfo_args_out(struct srvsvc_NetFileGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_srvsvc_NetFileInfo(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_srvsvc_NetFileClose_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileClose *r)
{
	PyObject *py_server_unc;
	PyObject *py_fid;
	const char *kwnames[] = {
		"server_unc", "fid", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetFileClose", discard_const_p(char *, kwnames), &py_server_unc, &py_fid)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_fid, return false;);
	r->in.fid = PyInt_AsLong(py_fid);
	return true;
}

static PyObject *unpack_py_srvsvc_NetFileClose_args_out(struct srvsvc_NetFileClose *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_srvsvc_NetSessEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSessEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_client;
	PyObject *py_user;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "client", "user", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetSessEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_client, &py_user, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_client == Py_None) {
		r->in.client = NULL;
	} else {
		r->in.client = NULL;
		if (PyUnicode_Check(py_client)) {
			r->in.client = PyString_AS_STRING(PyUnicode_AsEncodedString(py_client, "utf-8", "ignore"));
		} else if (PyString_Check(py_client)) {
			r->in.client = PyString_AS_STRING(py_client);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_client)->tp_name);
			return false;
		}
	}
	if (py_user == Py_None) {
		r->in.user = NULL;
	} else {
		r->in.user = NULL;
		if (PyUnicode_Check(py_user)) {
			r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
		} else if (PyString_Check(py_user)) {
			r->in.user = PyString_AS_STRING(py_user);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
			return false;
		}
	}
	r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetSessInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetSessEnum_args_out(struct srvsvc_NetSessEnum *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetSessInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetSessDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSessDel *r)
{
	PyObject *py_server_unc;
	PyObject *py_client;
	PyObject *py_user;
	const char *kwnames[] = {
		"server_unc", "client", "user", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetSessDel", discard_const_p(char *, kwnames), &py_server_unc, &py_client, &py_user)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_client == Py_None) {
		r->in.client = NULL;
	} else {
		r->in.client = NULL;
		if (PyUnicode_Check(py_client)) {
			r->in.client = PyString_AS_STRING(PyUnicode_AsEncodedString(py_client, "utf-8", "ignore"));
		} else if (PyString_Check(py_client)) {
			r->in.client = PyString_AS_STRING(py_client);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_client)->tp_name);
			return false;
		}
	}
	if (py_user == Py_None) {
		r->in.user = NULL;
	} else {
		r->in.user = NULL;
		if (PyUnicode_Check(py_user)) {
			r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
		} else if (PyString_Check(py_user)) {
			r->in.user = PyString_AS_STRING(py_user);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetSessDel_args_out(struct srvsvc_NetSessDel *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_srvsvc_NetShareAdd_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareAdd *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_parm_error;
	const char *kwnames[] = {
		"server_unc", "level", "info", "parm_error", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareAdd", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_parm_error)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->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 srvsvc_NetShareInfo *info_switch_1;
		info_switch_1 = py_export_srvsvc_NetShareInfo(r, r->in.level, py_info);
		if (info_switch_1 == NULL) {
			return false;
		}
		r->in.info = info_switch_1;
	}
	if (py_parm_error == Py_None) {
		r->in.parm_error = NULL;
	} else {
		r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
		*r->in.parm_error = PyInt_AsLong(py_parm_error);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareAdd_args_out(struct srvsvc_NetShareAdd *r)
{
	PyObject *result;
	PyObject *py_parm_error;
	if (r->out.parm_error == NULL) {
		py_parm_error = Py_None;
		Py_INCREF(py_parm_error);
	} else {
		py_parm_error = PyInt_FromLong(*r->out.parm_error);
	}
	result = py_parm_error;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetShareEnumAll_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareEnumAll *r)
{
	PyObject *py_server_unc;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareEnumAll", discard_const_p(char *, kwnames), &py_server_unc, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetShareInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareEnumAll_args_out(struct srvsvc_NetShareEnumAll *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetShareInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetShareGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareGetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_share_name;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_unc", "share_name", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_level)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(py_share_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->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_srvsvc_NetShareGetInfo_args_out(struct srvsvc_NetShareGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_srvsvc_NetShareInfo(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_srvsvc_NetShareSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareSetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_share_name;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_parm_error;
	const char *kwnames[] = {
		"server_unc", "share_name", "level", "info", "parm_error", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetShareSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_level, &py_info, &py_parm_error)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(py_share_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->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 srvsvc_NetShareInfo *info_switch_1;
		info_switch_1 = py_export_srvsvc_NetShareInfo(r, r->in.level, py_info);
		if (info_switch_1 == NULL) {
			return false;
		}
		r->in.info = info_switch_1;
	}
	if (py_parm_error == Py_None) {
		r->in.parm_error = NULL;
	} else {
		r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
		*r->in.parm_error = PyInt_AsLong(py_parm_error);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareSetInfo_args_out(struct srvsvc_NetShareSetInfo *r)
{
	PyObject *result;
	PyObject *py_parm_error;
	if (r->out.parm_error == NULL) {
		py_parm_error = Py_None;
		Py_INCREF(py_parm_error);
	} else {
		py_parm_error = PyInt_FromLong(*r->out.parm_error);
	}
	result = py_parm_error;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetShareDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDel *r)
{
	PyObject *py_server_unc;
	PyObject *py_share_name;
	PyObject *py_reserved;
	const char *kwnames[] = {
		"server_unc", "share_name", "reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDel", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_reserved)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(py_share_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
	r->in.reserved = PyInt_AsLong(py_reserved);
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareDel_args_out(struct srvsvc_NetShareDel *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_srvsvc_NetShareDelSticky_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelSticky *r)
{
	PyObject *py_server_unc;
	PyObject *py_share_name;
	PyObject *py_reserved;
	const char *kwnames[] = {
		"server_unc", "share_name", "reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDelSticky", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_reserved)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_share_name)) {
		r->in.share_name = PyString_AS_STRING(py_share_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
	r->in.reserved = PyInt_AsLong(py_reserved);
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareDelSticky_args_out(struct srvsvc_NetShareDelSticky *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_srvsvc_NetShareCheck_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareCheck *r)
{
	PyObject *py_server_unc;
	PyObject *py_device_name;
	const char *kwnames[] = {
		"server_unc", "device_name", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetShareCheck", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_device_name)) {
		r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_device_name)) {
		r->in.device_name = PyString_AS_STRING(py_device_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
		return false;
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareCheck_args_out(struct srvsvc_NetShareCheck *r)
{
	PyObject *result;
	PyObject *py_type;
	py_type = PyInt_FromLong(*r->out.type);
	result = py_type;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetSrvGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSrvGetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_unc", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetSrvGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_level)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->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_srvsvc_NetSrvGetInfo_args_out(struct srvsvc_NetSrvGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_srvsvc_NetSrvInfo(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_srvsvc_NetSrvSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSrvSetInfo *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_parm_error;
	const char *kwnames[] = {
		"server_unc", "level", "info", "parm_error", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetSrvSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_parm_error)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->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 srvsvc_NetSrvInfo *info_switch_1;
		info_switch_1 = py_export_srvsvc_NetSrvInfo(r, r->in.level, py_info);
		if (info_switch_1 == NULL) {
			return false;
		}
		r->in.info = info_switch_1;
	}
	if (py_parm_error == Py_None) {
		r->in.parm_error = NULL;
	} else {
		r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
		*r->in.parm_error = PyInt_AsLong(py_parm_error);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetSrvSetInfo_args_out(struct srvsvc_NetSrvSetInfo *r)
{
	PyObject *result;
	PyObject *py_parm_error;
	if (r->out.parm_error == NULL) {
		py_parm_error = Py_None;
		Py_INCREF(py_parm_error);
	} else {
		py_parm_error = PyInt_FromLong(*r->out.parm_error);
	}
	result = py_parm_error;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetDiskEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetDiskEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_maxlen;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "level", "info", "maxlen", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetDiskEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_maxlen, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->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);
	PY_CHECK_TYPE(&srvsvc_NetDiskInfo_Type, py_info, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_info);
	PY_CHECK_TYPE(&PyInt_Type, py_maxlen, return false;);
	r->in.maxlen = PyInt_AsLong(py_maxlen);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetDiskEnum_args_out(struct srvsvc_NetDiskEnum *r)
{
	PyObject *result;
	PyObject *py_info;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info = pytalloc_reference_ex(&srvsvc_NetDiskInfo_Type, r->out.info, r->out.info);
	PyTuple_SetItem(result, 0, py_info);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetServerStatisticsGet_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerStatisticsGet *r)
{
	PyObject *py_server_unc;
	PyObject *py_service;
	PyObject *py_level;
	PyObject *py_options;
	const char *kwnames[] = {
		"server_unc", "service", "level", "options", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetServerStatisticsGet", discard_const_p(char *, kwnames), &py_server_unc, &py_service, &py_level, &py_options)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_service == Py_None) {
		r->in.service = NULL;
	} else {
		r->in.service = NULL;
		if (PyUnicode_Check(py_service)) {
			r->in.service = PyString_AS_STRING(PyUnicode_AsEncodedString(py_service, "utf-8", "ignore"));
		} else if (PyString_Check(py_service)) {
			r->in.service = PyString_AS_STRING(py_service);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_service)->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_options, return false;);
	r->in.options = PyInt_AsLong(py_options);
	return true;
}

static PyObject *unpack_py_srvsvc_NetServerStatisticsGet_args_out(struct srvsvc_NetServerStatisticsGet *r)
{
	PyObject *result;
	PyObject *py_stats;
	if (*r->out.stats == NULL) {
		py_stats = Py_None;
		Py_INCREF(py_stats);
	} else {
		py_stats = pytalloc_reference_ex(&srvsvc_Statistics_Type, *r->out.stats, *r->out.stats);
	}
	result = py_stats;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetTransportAdd_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportAdd *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	PyObject *py_info;
	const char *kwnames[] = {
		"server_unc", "level", "info", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetTransportAdd", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	{
		union srvsvc_NetTransportInfo *info_switch_0;
		info_switch_0 = py_export_srvsvc_NetTransportInfo(r, r->in.level, py_info);
		if (info_switch_0 == NULL) {
			return false;
		}
		r->in.info = *info_switch_0;
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetTransportAdd_args_out(struct srvsvc_NetTransportAdd *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_srvsvc_NetTransportEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_transports;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "transports", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetTransportEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_transports, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	r->in.transports = talloc_ptrtype(r, r->in.transports);
	PY_CHECK_TYPE(&srvsvc_NetTransportInfoCtr_Type, py_transports, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_transports)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.transports = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_transports);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetTransportEnum_args_out(struct srvsvc_NetTransportEnum *r)
{
	PyObject *result;
	PyObject *py_transports;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_transports = pytalloc_reference_ex(&srvsvc_NetTransportInfoCtr_Type, r->out.transports, r->out.transports);
	PyTuple_SetItem(result, 0, py_transports);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetTransportDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportDel *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	PyObject *py_info0;
	const char *kwnames[] = {
		"server_unc", "level", "info0", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetTransportDel", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info0)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	r->in.info0 = talloc_ptrtype(r, r->in.info0);
	PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, py_info0, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info0)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info0 = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_info0);
	return true;
}

static PyObject *unpack_py_srvsvc_NetTransportDel_args_out(struct srvsvc_NetTransportDel *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_srvsvc_NetRemoteTOD_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetRemoteTOD *r)
{
	PyObject *py_server_unc;
	const char *kwnames[] = {
		"server_unc", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:srvsvc_NetRemoteTOD", discard_const_p(char *, kwnames), &py_server_unc)) {
		return false;
	}

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

static PyObject *unpack_py_srvsvc_NetRemoteTOD_args_out(struct srvsvc_NetRemoteTOD *r)
{
	PyObject *result;
	PyObject *py_info;
	if (*r->out.info == NULL) {
		py_info = Py_None;
		Py_INCREF(py_info);
	} else {
		py_info = pytalloc_reference_ex(&srvsvc_NetRemoteTODInfo_Type, *r->out.info, *r->out.info);
	}
	result = py_info;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetSetServiceBits_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSetServiceBits *r)
{
	PyObject *py_server_unc;
	PyObject *py_transport;
	PyObject *py_servicebits;
	PyObject *py_updateimmediately;
	const char *kwnames[] = {
		"server_unc", "transport", "servicebits", "updateimmediately", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetSetServiceBits", discard_const_p(char *, kwnames), &py_server_unc, &py_transport, &py_servicebits, &py_updateimmediately)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_transport == Py_None) {
		r->in.transport = NULL;
	} else {
		r->in.transport = NULL;
		if (PyUnicode_Check(py_transport)) {
			r->in.transport = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport, "utf-8", "ignore"));
		} else if (PyString_Check(py_transport)) {
			r->in.transport = PyString_AS_STRING(py_transport);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_servicebits, return false;);
	r->in.servicebits = PyInt_AsLong(py_servicebits);
	PY_CHECK_TYPE(&PyInt_Type, py_updateimmediately, return false;);
	r->in.updateimmediately = PyInt_AsLong(py_updateimmediately);
	return true;
}

static PyObject *unpack_py_srvsvc_NetSetServiceBits_args_out(struct srvsvc_NetSetServiceBits *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_srvsvc_NetPathType_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathType *r)
{
	PyObject *py_server_unc;
	PyObject *py_path;
	PyObject *py_pathflags;
	const char *kwnames[] = {
		"server_unc", "path", "pathflags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetPathType", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_pathflags)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	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;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
	r->in.pathflags = PyInt_AsLong(py_pathflags);
	return true;
}

static PyObject *unpack_py_srvsvc_NetPathType_args_out(struct srvsvc_NetPathType *r)
{
	PyObject *result;
	PyObject *py_pathtype;
	py_pathtype = PyInt_FromLong(*r->out.pathtype);
	result = py_pathtype;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetPathCanonicalize_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathCanonicalize *r)
{
	PyObject *py_server_unc;
	PyObject *py_path;
	PyObject *py_maxbuf;
	PyObject *py_prefix;
	PyObject *py_pathtype;
	PyObject *py_pathflags;
	const char *kwnames[] = {
		"server_unc", "path", "maxbuf", "prefix", "pathtype", "pathflags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetPathCanonicalize", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_maxbuf, &py_prefix, &py_pathtype, &py_pathflags)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	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;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_maxbuf, return false;);
	r->in.maxbuf = PyInt_AsLong(py_maxbuf);
	if (PyUnicode_Check(py_prefix)) {
		r->in.prefix = PyString_AS_STRING(PyUnicode_AsEncodedString(py_prefix, "utf-8", "ignore"));
	} else if (PyString_Check(py_prefix)) {
		r->in.prefix = PyString_AS_STRING(py_prefix);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_prefix)->tp_name);
		return false;
	}
	r->in.pathtype = talloc_ptrtype(r, r->in.pathtype);
	PY_CHECK_TYPE(&PyInt_Type, py_pathtype, return false;);
	*r->in.pathtype = PyInt_AsLong(py_pathtype);
	PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
	r->in.pathflags = PyInt_AsLong(py_pathflags);
	return true;
}

static PyObject *unpack_py_srvsvc_NetPathCanonicalize_args_out(struct srvsvc_NetPathCanonicalize *r)
{
	PyObject *result;
	PyObject *py_can_path;
	PyObject *py_pathtype;
	result = PyTuple_New(2);
	py_can_path = PyList_New(r->in.maxbuf);
	if (py_can_path == NULL) {
		return NULL;
	}
	{
		int can_path_cntr_0;
		for (can_path_cntr_0 = 0; can_path_cntr_0 < r->in.maxbuf; can_path_cntr_0++) {
			PyObject *py_can_path_0;
			py_can_path_0 = PyInt_FromLong(r->out.can_path[can_path_cntr_0]);
			PyList_SetItem(py_can_path, can_path_cntr_0, py_can_path_0);
		}
	}
	PyTuple_SetItem(result, 0, py_can_path);
	py_pathtype = PyInt_FromLong(*r->out.pathtype);
	PyTuple_SetItem(result, 1, py_pathtype);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetPathCompare_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathCompare *r)
{
	PyObject *py_server_unc;
	PyObject *py_path1;
	PyObject *py_path2;
	PyObject *py_pathtype;
	PyObject *py_pathflags;
	const char *kwnames[] = {
		"server_unc", "path1", "path2", "pathtype", "pathflags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetPathCompare", discard_const_p(char *, kwnames), &py_server_unc, &py_path1, &py_path2, &py_pathtype, &py_pathflags)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_path1)) {
		r->in.path1 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path1, "utf-8", "ignore"));
	} else if (PyString_Check(py_path1)) {
		r->in.path1 = PyString_AS_STRING(py_path1);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path1)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_path2)) {
		r->in.path2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path2, "utf-8", "ignore"));
	} else if (PyString_Check(py_path2)) {
		r->in.path2 = PyString_AS_STRING(py_path2);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path2)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_pathtype, return false;);
	r->in.pathtype = PyInt_AsLong(py_pathtype);
	PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
	r->in.pathflags = PyInt_AsLong(py_pathflags);
	return true;
}

static PyObject *unpack_py_srvsvc_NetPathCompare_args_out(struct srvsvc_NetPathCompare *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_srvsvc_NetNameValidate_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetNameValidate *r)
{
	PyObject *py_server_unc;
	PyObject *py_name;
	PyObject *py_name_type;
	PyObject *py_flags;
	const char *kwnames[] = {
		"server_unc", "name", "name_type", "flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetNameValidate", discard_const_p(char *, kwnames), &py_server_unc, &py_name, &py_name_type, &py_flags)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_name)) {
		r->in.name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_name)) {
		r->in.name = PyString_AS_STRING(py_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_name_type, return false;);
	r->in.name_type = PyInt_AsLong(py_name_type);
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	return true;
}

static PyObject *unpack_py_srvsvc_NetNameValidate_args_out(struct srvsvc_NetNameValidate *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_srvsvc_NetPRNameCompare_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPRNameCompare *r)
{
	PyObject *py_server_unc;
	PyObject *py_name1;
	PyObject *py_name2;
	PyObject *py_name_type;
	PyObject *py_flags;
	const char *kwnames[] = {
		"server_unc", "name1", "name2", "name_type", "flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetPRNameCompare", discard_const_p(char *, kwnames), &py_server_unc, &py_name1, &py_name2, &py_name_type, &py_flags)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (PyUnicode_Check(py_name1)) {
		r->in.name1 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name1, "utf-8", "ignore"));
	} else if (PyString_Check(py_name1)) {
		r->in.name1 = PyString_AS_STRING(py_name1);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name1)->tp_name);
		return false;
	}
	if (PyUnicode_Check(py_name2)) {
		r->in.name2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name2, "utf-8", "ignore"));
	} else if (PyString_Check(py_name2)) {
		r->in.name2 = PyString_AS_STRING(py_name2);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name2)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_name_type, return false;);
	r->in.name_type = PyInt_AsLong(py_name_type);
	PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
	r->in.flags = PyInt_AsLong(py_flags);
	return true;
}

static PyObject *unpack_py_srvsvc_NetPRNameCompare_args_out(struct srvsvc_NetPRNameCompare *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_srvsvc_NetShareEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareEnum *r)
{
	PyObject *py_server_unc;
	PyObject *py_info_ctr;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
	PY_CHECK_TYPE(&srvsvc_NetShareInfoCtr_Type, py_info_ctr, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info_ctr = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_info_ctr);
	PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
	r->in.max_buffer = PyInt_AsLong(py_max_buffer);
	if (py_resume_handle == Py_None) {
		r->in.resume_handle = NULL;
	} else {
		r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
		PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
		*r->in.resume_handle = PyInt_AsLong(py_resume_handle);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareEnum_args_out(struct srvsvc_NetShareEnum *r)
{
	PyObject *result;
	PyObject *py_info_ctr;
	PyObject *py_totalentries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info_ctr = pytalloc_reference_ex(&srvsvc_NetShareInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
	PyTuple_SetItem(result, 0, py_info_ctr);
	py_totalentries = PyInt_FromLong(*r->out.totalentries);
	PyTuple_SetItem(result, 1, py_totalentries);
	if (r->out.resume_handle == NULL) {
		py_resume_handle = Py_None;
		Py_INCREF(py_resume_handle);
	} else {
		py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
	}
	PyTuple_SetItem(result, 2, py_resume_handle);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetShareDelStart_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelStart *r)
{
	PyObject *py_server_unc;
	PyObject *py_share;
	PyObject *py_reserved;
	const char *kwnames[] = {
		"server_unc", "share", "reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDelStart", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_reserved)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	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;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
	r->in.reserved = PyInt_AsLong(py_reserved);
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareDelStart_args_out(struct srvsvc_NetShareDelStart *r)
{
	PyObject *result;
	PyObject *py_hnd;
	if (r->out.hnd == NULL) {
		py_hnd = Py_None;
		Py_INCREF(py_hnd);
	} else {
		py_hnd = pytalloc_reference_ex(policy_handle_Type, r->out.hnd, r->out.hnd);
	}
	result = py_hnd;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetShareDelCommit_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelCommit *r)
{
	PyObject *py_hnd;
	const char *kwnames[] = {
		"hnd", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:srvsvc_NetShareDelCommit", discard_const_p(char *, kwnames), &py_hnd)) {
		return false;
	}

	if (py_hnd == Py_None) {
		r->in.hnd = NULL;
	} else {
		r->in.hnd = NULL;
		PY_CHECK_TYPE(policy_handle_Type, py_hnd, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_hnd)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.hnd = (struct policy_handle *)pytalloc_get_ptr(py_hnd);
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetShareDelCommit_args_out(struct srvsvc_NetShareDelCommit *r)
{
	PyObject *result;
	PyObject *py_hnd;
	if (r->out.hnd == NULL) {
		py_hnd = Py_None;
		Py_INCREF(py_hnd);
	} else {
		py_hnd = pytalloc_reference_ex(policy_handle_Type, r->out.hnd, r->out.hnd);
	}
	result = py_hnd;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetGetFileSecurity_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetGetFileSecurity *r)
{
	PyObject *py_server_unc;
	PyObject *py_share;
	PyObject *py_file;
	PyObject *py_securityinformation;
	const char *kwnames[] = {
		"server_unc", "share", "file", "securityinformation", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetGetFileSecurity", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_file, &py_securityinformation)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->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 (PyUnicode_Check(py_file)) {
		r->in.file = PyString_AS_STRING(PyUnicode_AsEncodedString(py_file, "utf-8", "ignore"));
	} else if (PyString_Check(py_file)) {
		r->in.file = PyString_AS_STRING(py_file);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_file)->tp_name);
		return false;
	}
	if (PyLong_Check(py_securityinformation)) {
		r->in.securityinformation = PyLong_AsLongLong(py_securityinformation);
	} else if (PyInt_Check(py_securityinformation)) {
		r->in.securityinformation = PyInt_AsLong(py_securityinformation);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return false;
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetGetFileSecurity_args_out(struct srvsvc_NetGetFileSecurity *r)
{
	PyObject *result;
	PyObject *py_sd_buf;
	if (*r->out.sd_buf == NULL) {
		py_sd_buf = Py_None;
		Py_INCREF(py_sd_buf);
	} else {
		py_sd_buf = pytalloc_reference_ex(sec_desc_buf_Type, *r->out.sd_buf, *r->out.sd_buf);
	}
	result = py_sd_buf;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_srvsvc_NetSetFileSecurity_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSetFileSecurity *r)
{
	PyObject *py_server_unc;
	PyObject *py_share;
	PyObject *py_file;
	PyObject *py_securityinformation;
	PyObject *py_sd_buf;
	const char *kwnames[] = {
		"server_unc", "share", "file", "securityinformation", "sd_buf", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetSetFileSecurity", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_file, &py_securityinformation, &py_sd_buf)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->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 (PyUnicode_Check(py_file)) {
		r->in.file = PyString_AS_STRING(PyUnicode_AsEncodedString(py_file, "utf-8", "ignore"));
	} else if (PyString_Check(py_file)) {
		r->in.file = PyString_AS_STRING(py_file);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_file)->tp_name);
		return false;
	}
	if (PyLong_Check(py_securityinformation)) {
		r->in.securityinformation = PyLong_AsLongLong(py_securityinformation);
	} else if (PyInt_Check(py_securityinformation)) {
		r->in.securityinformation = PyInt_AsLong(py_securityinformation);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.tp_name);
		return false;
	}
	r->in.sd_buf = talloc_ptrtype(r, r->in.sd_buf);
	PY_CHECK_TYPE(sec_desc_buf_Type, py_sd_buf, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_sd_buf)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.sd_buf = (struct sec_desc_buf *)pytalloc_get_ptr(py_sd_buf);
	return true;
}

static PyObject *unpack_py_srvsvc_NetSetFileSecurity_args_out(struct srvsvc_NetSetFileSecurity *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_srvsvc_NetServerTransportAddEx_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerTransportAddEx *r)
{
	PyObject *py_server_unc;
	PyObject *py_level;
	PyObject *py_info;
	const char *kwnames[] = {
		"server_unc", "level", "info", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetServerTransportAddEx", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	{
		union srvsvc_NetTransportInfo *info_switch_0;
		info_switch_0 = py_export_srvsvc_NetTransportInfo(r, r->in.level, py_info);
		if (info_switch_0 == NULL) {
			return false;
		}
		r->in.info = *info_switch_0;
	}
	return true;
}

static PyObject *unpack_py_srvsvc_NetServerTransportAddEx_args_out(struct srvsvc_NetServerTransportAddEx *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_srvsvc_NetServerSetServiceBitsEx_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerSetServiceBitsEx *r)
{
	PyObject *py_server_unc;
	PyObject *py_emulated_server_unc;
	PyObject *py_transport;
	PyObject *py_servicebitsofinterest;
	PyObject *py_servicebits;
	PyObject *py_updateimmediately;
	const char *kwnames[] = {
		"server_unc", "emulated_server_unc", "transport", "servicebitsofinterest", "servicebits", "updateimmediately", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetServerSetServiceBitsEx", discard_const_p(char *, kwnames), &py_server_unc, &py_emulated_server_unc, &py_transport, &py_servicebitsofinterest, &py_servicebits, &py_updateimmediately)) {
		return false;
	}

	if (py_server_unc == Py_None) {
		r->in.server_unc = NULL;
	} else {
		r->in.server_unc = NULL;
		if (PyUnicode_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_unc)) {
			r->in.server_unc = PyString_AS_STRING(py_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
			return false;
		}
	}
	if (py_emulated_server_unc == Py_None) {
		r->in.emulated_server_unc = NULL;
	} else {
		r->in.emulated_server_unc = NULL;
		if (PyUnicode_Check(py_emulated_server_unc)) {
			r->in.emulated_server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_emulated_server_unc, "utf-8", "ignore"));
		} else if (PyString_Check(py_emulated_server_unc)) {
			r->in.emulated_server_unc = PyString_AS_STRING(py_emulated_server_unc);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_emulated_server_unc)->tp_name);
			return false;
		}
	}
	if (py_transport == Py_None) {
		r->in.transport = NULL;
	} else {
		r->in.transport = NULL;
		if (PyUnicode_Check(py_transport)) {
			r->in.transport = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport, "utf-8", "ignore"));
		} else if (PyString_Check(py_transport)) {
			r->in.transport = PyString_AS_STRING(py_transport);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_servicebitsofinterest, return false;);
	r->in.servicebitsofinterest = PyInt_AsLong(py_servicebitsofinterest);
	PY_CHECK_TYPE(&PyInt_Type, py_servicebits, return false;);
	r->in.servicebits = PyInt_AsLong(py_servicebits);
	PY_CHECK_TYPE(&PyInt_Type, py_updateimmediately, return false;);
	r->in.updateimmediately = PyInt_AsLong(py_updateimmediately);
	return true;
}

static PyObject *unpack_py_srvsvc_NetServerSetServiceBitsEx_args_out(struct srvsvc_NetServerSetServiceBitsEx *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;
}

const struct PyNdrRpcMethodDef py_ndr_srvsvc_methods[] = {
	{ "NetCharDevEnum", "S.NetCharDevEnum(server_unc, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevEnum_args_out, 0, &ndr_table_srvsvc },
	{ "NetCharDevGetInfo", "S.NetCharDevGetInfo(server_unc, device_name, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevGetInfo_args_out, 1, &ndr_table_srvsvc },
	{ "NetCharDevControl", "S.NetCharDevControl(server_unc, device_name, opcode) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevControl_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevControl_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevControl_args_out, 2, &ndr_table_srvsvc },
	{ "NetCharDevQEnum", "S.NetCharDevQEnum(server_unc, user, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQEnum_args_out, 3, &ndr_table_srvsvc },
	{ "NetCharDevQGetInfo", "S.NetCharDevQGetInfo(server_unc, queue_name, user, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQGetInfo_args_out, 4, &ndr_table_srvsvc },
	{ "NetCharDevQSetInfo", "S.NetCharDevQSetInfo(server_unc, queue_name, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQSetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQSetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQSetInfo_args_out, 5, &ndr_table_srvsvc },
	{ "NetCharDevQPurge", "S.NetCharDevQPurge(server_unc, queue_name) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQPurge_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQPurge_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQPurge_args_out, 6, &ndr_table_srvsvc },
	{ "NetCharDevQPurgeSelf", "S.NetCharDevQPurgeSelf(server_unc, queue_name, computer_name) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQPurgeSelf_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQPurgeSelf_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQPurgeSelf_args_out, 7, &ndr_table_srvsvc },
	{ "NetConnEnum", "S.NetConnEnum(server_unc, path, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetConnEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetConnEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetConnEnum_args_out, 8, &ndr_table_srvsvc },
	{ "NetFileEnum", "S.NetFileEnum(server_unc, path, user, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetFileEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetFileEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetFileEnum_args_out, 9, &ndr_table_srvsvc },
	{ "NetFileGetInfo", "S.NetFileGetInfo(server_unc, fid, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetFileGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetFileGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetFileGetInfo_args_out, 10, &ndr_table_srvsvc },
	{ "NetFileClose", "S.NetFileClose(server_unc, fid) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetFileClose_r, (py_data_pack_fn)pack_py_srvsvc_NetFileClose_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetFileClose_args_out, 11, &ndr_table_srvsvc },
	{ "NetSessEnum", "S.NetSessEnum(server_unc, client, user, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSessEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetSessEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSessEnum_args_out, 12, &ndr_table_srvsvc },
	{ "NetSessDel", "S.NetSessDel(server_unc, client, user) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSessDel_r, (py_data_pack_fn)pack_py_srvsvc_NetSessDel_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSessDel_args_out, 13, &ndr_table_srvsvc },
	{ "NetShareAdd", "S.NetShareAdd(server_unc, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareAdd_r, (py_data_pack_fn)pack_py_srvsvc_NetShareAdd_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareAdd_args_out, 14, &ndr_table_srvsvc },
	{ "NetShareEnumAll", "S.NetShareEnumAll(server_unc, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareEnumAll_r, (py_data_pack_fn)pack_py_srvsvc_NetShareEnumAll_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareEnumAll_args_out, 15, &ndr_table_srvsvc },
	{ "NetShareGetInfo", "S.NetShareGetInfo(server_unc, share_name, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetShareGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareGetInfo_args_out, 16, &ndr_table_srvsvc },
	{ "NetShareSetInfo", "S.NetShareSetInfo(server_unc, share_name, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareSetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetShareSetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareSetInfo_args_out, 17, &ndr_table_srvsvc },
	{ "NetShareDel", "S.NetShareDel(server_unc, share_name, reserved) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDel_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDel_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDel_args_out, 18, &ndr_table_srvsvc },
	{ "NetShareDelSticky", "S.NetShareDelSticky(server_unc, share_name, reserved) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDelSticky_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDelSticky_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDelSticky_args_out, 19, &ndr_table_srvsvc },
	{ "NetShareCheck", "S.NetShareCheck(server_unc, device_name) -> type", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareCheck_r, (py_data_pack_fn)pack_py_srvsvc_NetShareCheck_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareCheck_args_out, 20, &ndr_table_srvsvc },
	{ "NetSrvGetInfo", "S.NetSrvGetInfo(server_unc, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSrvGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetSrvGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSrvGetInfo_args_out, 21, &ndr_table_srvsvc },
	{ "NetSrvSetInfo", "S.NetSrvSetInfo(server_unc, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSrvSetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetSrvSetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSrvSetInfo_args_out, 22, &ndr_table_srvsvc },
	{ "NetDiskEnum", "S.NetDiskEnum(server_unc, level, info, maxlen, resume_handle) -> (info, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetDiskEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetDiskEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetDiskEnum_args_out, 23, &ndr_table_srvsvc },
	{ "NetServerStatisticsGet", "S.NetServerStatisticsGet(server_unc, service, level, options) -> stats", (py_dcerpc_call_fn)dcerpc_srvsvc_NetServerStatisticsGet_r, (py_data_pack_fn)pack_py_srvsvc_NetServerStatisticsGet_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetServerStatisticsGet_args_out, 24, &ndr_table_srvsvc },
	{ "NetTransportAdd", "S.NetTransportAdd(server_unc, level, info) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetTransportAdd_r, (py_data_pack_fn)pack_py_srvsvc_NetTransportAdd_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetTransportAdd_args_out, 25, &ndr_table_srvsvc },
	{ "NetTransportEnum", "S.NetTransportEnum(server_unc, transports, max_buffer, resume_handle) -> (transports, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetTransportEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetTransportEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetTransportEnum_args_out, 26, &ndr_table_srvsvc },
	{ "NetTransportDel", "S.NetTransportDel(server_unc, level, info0) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetTransportDel_r, (py_data_pack_fn)pack_py_srvsvc_NetTransportDel_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetTransportDel_args_out, 27, &ndr_table_srvsvc },
	{ "NetRemoteTOD", "S.NetRemoteTOD(server_unc) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetRemoteTOD_r, (py_data_pack_fn)pack_py_srvsvc_NetRemoteTOD_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetRemoteTOD_args_out, 28, &ndr_table_srvsvc },
	{ "NetSetServiceBits", "S.NetSetServiceBits(server_unc, transport, servicebits, updateimmediately) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSetServiceBits_r, (py_data_pack_fn)pack_py_srvsvc_NetSetServiceBits_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSetServiceBits_args_out, 29, &ndr_table_srvsvc },
	{ "NetPathType", "S.NetPathType(server_unc, path, pathflags) -> pathtype", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPathType_r, (py_data_pack_fn)pack_py_srvsvc_NetPathType_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPathType_args_out, 30, &ndr_table_srvsvc },
	{ "NetPathCanonicalize", "S.NetPathCanonicalize(server_unc, path, maxbuf, prefix, pathtype, pathflags) -> (can_path, pathtype)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPathCanonicalize_r, (py_data_pack_fn)pack_py_srvsvc_NetPathCanonicalize_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPathCanonicalize_args_out, 31, &ndr_table_srvsvc },
	{ "NetPathCompare", "S.NetPathCompare(server_unc, path1, path2, pathtype, pathflags) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPathCompare_r, (py_data_pack_fn)pack_py_srvsvc_NetPathCompare_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPathCompare_args_out, 32, &ndr_table_srvsvc },
	{ "NetNameValidate", "S.NetNameValidate(server_unc, name, name_type, flags) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetNameValidate_r, (py_data_pack_fn)pack_py_srvsvc_NetNameValidate_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetNameValidate_args_out, 33, &ndr_table_srvsvc },
	{ "NetPRNameCompare", "S.NetPRNameCompare(server_unc, name1, name2, name_type, flags) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPRNameCompare_r, (py_data_pack_fn)pack_py_srvsvc_NetPRNameCompare_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPRNameCompare_args_out, 35, &ndr_table_srvsvc },
	{ "NetShareEnum", "S.NetShareEnum(server_unc, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetShareEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareEnum_args_out, 36, &ndr_table_srvsvc },
	{ "NetShareDelStart", "S.NetShareDelStart(server_unc, share, reserved) -> hnd", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDelStart_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDelStart_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDelStart_args_out, 37, &ndr_table_srvsvc },
	{ "NetShareDelCommit", "S.NetShareDelCommit(hnd) -> hnd", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDelCommit_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDelCommit_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDelCommit_args_out, 38, &ndr_table_srvsvc },
	{ "NetGetFileSecurity", "S.NetGetFileSecurity(server_unc, share, file, securityinformation) -> sd_buf", (py_dcerpc_call_fn)dcerpc_srvsvc_NetGetFileSecurity_r, (py_data_pack_fn)pack_py_srvsvc_NetGetFileSecurity_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetGetFileSecurity_args_out, 39, &ndr_table_srvsvc },
	{ "NetSetFileSecurity", "S.NetSetFileSecurity(server_unc, share, file, securityinformation, sd_buf) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSetFileSecurity_r, (py_data_pack_fn)pack_py_srvsvc_NetSetFileSecurity_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSetFileSecurity_args_out, 40, &ndr_table_srvsvc },
	{ "NetServerTransportAddEx", "S.NetServerTransportAddEx(server_unc, level, info) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetServerTransportAddEx_r, (py_data_pack_fn)pack_py_srvsvc_NetServerTransportAddEx_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetServerTransportAddEx_args_out, 41, &ndr_table_srvsvc },
	{ "NetServerSetServiceBitsEx", "S.NetServerSetServiceBitsEx(server_unc, emulated_server_unc, transport, servicebitsofinterest, servicebits, updateimmediately) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetServerSetServiceBitsEx_r, (py_data_pack_fn)pack_py_srvsvc_NetServerSetServiceBitsEx_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetServerSetServiceBitsEx_args_out, 42, &ndr_table_srvsvc },
	{ NULL }
};

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

#define PY_DOC_SRVSVC "Server Service"
static PyTypeObject srvsvc_InterfaceType = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "srvsvc.srvsvc",
	.tp_basicsize = sizeof(dcerpc_InterfaceObject),
	.tp_doc = "srvsvc(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_SRVSVC,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = interface_srvsvc_new,
};

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

void initsrvsvc(void)
{
	PyObject *m;
	PyObject *dep_samba_dcerpc_security;
	PyObject *dep_talloc;
	PyObject *dep_samba_dcerpc_misc;
	PyObject *dep_samba_dcerpc_base;
	PyObject *dep_samba_dcerpc_svcctl;

	dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
	if (dep_samba_dcerpc_security == NULL)
		return;

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

	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_samba_dcerpc_svcctl = PyImport_ImportModule("samba.dcerpc.svcctl");
	if (dep_samba_dcerpc_svcctl == NULL)
		return;

	sec_desc_buf_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "sec_desc_buf");
	if (sec_desc_buf_Type == NULL)
		return;

	policy_handle_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "policy_handle");
	if (policy_handle_Type == 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;

	srvsvc_NetCharDevInfo0_Type.tp_base = Object_Type;

	srvsvc_NetCharDevCtr0_Type.tp_base = Object_Type;

	srvsvc_NetCharDevInfo1_Type.tp_base = Object_Type;

	srvsvc_NetCharDevCtr1_Type.tp_base = Object_Type;

	srvsvc_NetCharDevInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetCharDevQInfo0_Type.tp_base = Object_Type;

	srvsvc_NetCharDevQCtr0_Type.tp_base = Object_Type;

	srvsvc_NetCharDevQInfo1_Type.tp_base = Object_Type;

	srvsvc_NetCharDevQCtr1_Type.tp_base = Object_Type;

	srvsvc_NetCharDevQInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetConnInfo0_Type.tp_base = Object_Type;

	srvsvc_NetConnCtr0_Type.tp_base = Object_Type;

	srvsvc_NetConnInfo1_Type.tp_base = Object_Type;

	srvsvc_NetConnCtr1_Type.tp_base = Object_Type;

	srvsvc_NetConnInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetFileInfo2_Type.tp_base = Object_Type;

	srvsvc_NetFileCtr2_Type.tp_base = Object_Type;

	srvsvc_NetFileInfo3_Type.tp_base = Object_Type;

	srvsvc_NetFileCtr3_Type.tp_base = Object_Type;

	srvsvc_NetFileInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetSessInfo0_Type.tp_base = Object_Type;

	srvsvc_NetSessCtr0_Type.tp_base = Object_Type;

	srvsvc_NetSessInfo1_Type.tp_base = Object_Type;

	srvsvc_NetSessCtr1_Type.tp_base = Object_Type;

	srvsvc_NetSessInfo2_Type.tp_base = Object_Type;

	srvsvc_NetSessCtr2_Type.tp_base = Object_Type;

	srvsvc_NetSessInfo10_Type.tp_base = Object_Type;

	srvsvc_NetSessCtr10_Type.tp_base = Object_Type;

	srvsvc_NetSessInfo502_Type.tp_base = Object_Type;

	srvsvc_NetSessCtr502_Type.tp_base = Object_Type;

	srvsvc_NetSessInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo0_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr0_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo1_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr1_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo2_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr2_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo501_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr501_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo502_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr502_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo1004_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr1004_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo1005_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr1005_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo1006_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr1006_Type.tp_base = Object_Type;

	srvsvc_NetShareInfo1007_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr1007_Type.tp_base = Object_Type;

	srvsvc_NetShareCtr1501_Type.tp_base = Object_Type;

	srvsvc_NetShareInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo100_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo101_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo102_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo402_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo403_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo502_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo503_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo599_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1005_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1010_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1016_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1017_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1018_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1107_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1501_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1502_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1503_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1506_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1509_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1510_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1511_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1512_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1513_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1514_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1515_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1516_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1518_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1520_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1521_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1522_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1523_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1524_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1525_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1528_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1529_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1530_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1533_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1534_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1535_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1536_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1537_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1538_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1539_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1540_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1541_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1542_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1543_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1544_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1545_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1546_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1547_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1548_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1549_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1550_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1552_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1553_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1554_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1555_Type.tp_base = Object_Type;

	srvsvc_NetSrvInfo1556_Type.tp_base = Object_Type;

	srvsvc_NetDiskInfo0_Type.tp_base = Object_Type;

	srvsvc_NetDiskInfo_Type.tp_base = Object_Type;

	srvsvc_Statistics_Type.tp_base = Object_Type;

	srvsvc_NetTransportInfo0_Type.tp_base = Object_Type;

	srvsvc_NetTransportCtr0_Type.tp_base = Object_Type;

	srvsvc_NetTransportInfo1_Type.tp_base = Object_Type;

	srvsvc_NetTransportCtr1_Type.tp_base = Object_Type;

	srvsvc_NetTransportInfo2_Type.tp_base = Object_Type;

	srvsvc_NetTransportCtr2_Type.tp_base = Object_Type;

	srvsvc_NetTransportInfo3_Type.tp_base = Object_Type;

	srvsvc_NetTransportCtr3_Type.tp_base = Object_Type;

	srvsvc_NetTransportInfoCtr_Type.tp_base = Object_Type;

	srvsvc_NetRemoteTODInfo_Type.tp_base = Object_Type;

	srvsvc_InterfaceType.tp_base = ClientConnection_Type;

	if (PyType_Ready(&srvsvc_NetCharDevInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevCtr0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevInfo1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevCtr1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevQInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevQCtr0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevQInfo1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevQCtr1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetCharDevQInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetConnInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetConnCtr0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetConnInfo1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetConnCtr1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetConnInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetFileInfo2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetFileCtr2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetFileInfo3_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetFileCtr3_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetFileInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessCtr0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessInfo1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessCtr1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessInfo2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessCtr2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessInfo10_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessCtr10_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessInfo502_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessCtr502_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSessInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo501_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr501_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo502_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr502_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo1004_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr1004_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo1005_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr1005_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo1006_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr1006_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfo1007_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr1007_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareCtr1501_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetShareInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo100_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo101_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo102_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo402_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo403_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo502_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo503_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo599_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1005_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1010_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1016_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1017_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1018_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1107_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1501_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1502_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1503_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1506_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1509_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1510_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1511_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1512_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1513_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1514_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1515_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1516_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1518_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1520_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1521_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1522_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1523_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1524_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1525_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1528_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1529_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1530_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1533_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1534_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1535_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1536_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1537_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1538_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1539_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1540_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1541_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1542_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1543_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1544_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1545_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1546_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1547_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1548_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1549_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1550_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1552_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1553_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1554_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1555_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetSrvInfo1556_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetDiskInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetDiskInfo_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_Statistics_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportInfo0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportCtr0_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportInfo1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportCtr1_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportInfo2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportCtr2_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportInfo3_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportCtr3_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetTransportInfoCtr_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_NetRemoteTODInfo_Type) < 0)
		return;
	if (PyType_Ready(&srvsvc_InterfaceType) < 0)
		return;
	if (!PyInterface_AddNdrRpcMethods(&srvsvc_InterfaceType, py_ndr_srvsvc_methods))
		return;

#ifdef PY_NETCHARDEVINFO0_PATCH
	PY_NETCHARDEVINFO0_PATCH(&srvsvc_NetCharDevInfo0_Type);
#endif
#ifdef PY_NETCHARDEVCTR0_PATCH
	PY_NETCHARDEVCTR0_PATCH(&srvsvc_NetCharDevCtr0_Type);
#endif
#ifdef PY_NETCHARDEVINFO1_PATCH
	PY_NETCHARDEVINFO1_PATCH(&srvsvc_NetCharDevInfo1_Type);
#endif
#ifdef PY_NETCHARDEVCTR1_PATCH
	PY_NETCHARDEVCTR1_PATCH(&srvsvc_NetCharDevCtr1_Type);
#endif
#ifdef PY_NETCHARDEVINFOCTR_PATCH
	PY_NETCHARDEVINFOCTR_PATCH(&srvsvc_NetCharDevInfoCtr_Type);
#endif
#ifdef PY_NETCHARDEVQINFO0_PATCH
	PY_NETCHARDEVQINFO0_PATCH(&srvsvc_NetCharDevQInfo0_Type);
#endif
#ifdef PY_NETCHARDEVQCTR0_PATCH
	PY_NETCHARDEVQCTR0_PATCH(&srvsvc_NetCharDevQCtr0_Type);
#endif
#ifdef PY_NETCHARDEVQINFO1_PATCH
	PY_NETCHARDEVQINFO1_PATCH(&srvsvc_NetCharDevQInfo1_Type);
#endif
#ifdef PY_NETCHARDEVQCTR1_PATCH
	PY_NETCHARDEVQCTR1_PATCH(&srvsvc_NetCharDevQCtr1_Type);
#endif
#ifdef PY_NETCHARDEVQINFOCTR_PATCH
	PY_NETCHARDEVQINFOCTR_PATCH(&srvsvc_NetCharDevQInfoCtr_Type);
#endif
#ifdef PY_NETCONNINFO0_PATCH
	PY_NETCONNINFO0_PATCH(&srvsvc_NetConnInfo0_Type);
#endif
#ifdef PY_NETCONNCTR0_PATCH
	PY_NETCONNCTR0_PATCH(&srvsvc_NetConnCtr0_Type);
#endif
#ifdef PY_NETCONNINFO1_PATCH
	PY_NETCONNINFO1_PATCH(&srvsvc_NetConnInfo1_Type);
#endif
#ifdef PY_NETCONNCTR1_PATCH
	PY_NETCONNCTR1_PATCH(&srvsvc_NetConnCtr1_Type);
#endif
#ifdef PY_NETCONNINFOCTR_PATCH
	PY_NETCONNINFOCTR_PATCH(&srvsvc_NetConnInfoCtr_Type);
#endif
#ifdef PY_NETFILEINFO2_PATCH
	PY_NETFILEINFO2_PATCH(&srvsvc_NetFileInfo2_Type);
#endif
#ifdef PY_NETFILECTR2_PATCH
	PY_NETFILECTR2_PATCH(&srvsvc_NetFileCtr2_Type);
#endif
#ifdef PY_NETFILEINFO3_PATCH
	PY_NETFILEINFO3_PATCH(&srvsvc_NetFileInfo3_Type);
#endif
#ifdef PY_NETFILECTR3_PATCH
	PY_NETFILECTR3_PATCH(&srvsvc_NetFileCtr3_Type);
#endif
#ifdef PY_NETFILEINFOCTR_PATCH
	PY_NETFILEINFOCTR_PATCH(&srvsvc_NetFileInfoCtr_Type);
#endif
#ifdef PY_NETSESSINFO0_PATCH
	PY_NETSESSINFO0_PATCH(&srvsvc_NetSessInfo0_Type);
#endif
#ifdef PY_NETSESSCTR0_PATCH
	PY_NETSESSCTR0_PATCH(&srvsvc_NetSessCtr0_Type);
#endif
#ifdef PY_NETSESSINFO1_PATCH
	PY_NETSESSINFO1_PATCH(&srvsvc_NetSessInfo1_Type);
#endif
#ifdef PY_NETSESSCTR1_PATCH
	PY_NETSESSCTR1_PATCH(&srvsvc_NetSessCtr1_Type);
#endif
#ifdef PY_NETSESSINFO2_PATCH
	PY_NETSESSINFO2_PATCH(&srvsvc_NetSessInfo2_Type);
#endif
#ifdef PY_NETSESSCTR2_PATCH
	PY_NETSESSCTR2_PATCH(&srvsvc_NetSessCtr2_Type);
#endif
#ifdef PY_NETSESSINFO10_PATCH
	PY_NETSESSINFO10_PATCH(&srvsvc_NetSessInfo10_Type);
#endif
#ifdef PY_NETSESSCTR10_PATCH
	PY_NETSESSCTR10_PATCH(&srvsvc_NetSessCtr10_Type);
#endif
#ifdef PY_NETSESSINFO502_PATCH
	PY_NETSESSINFO502_PATCH(&srvsvc_NetSessInfo502_Type);
#endif
#ifdef PY_NETSESSCTR502_PATCH
	PY_NETSESSCTR502_PATCH(&srvsvc_NetSessCtr502_Type);
#endif
#ifdef PY_NETSESSINFOCTR_PATCH
	PY_NETSESSINFOCTR_PATCH(&srvsvc_NetSessInfoCtr_Type);
#endif
#ifdef PY_NETSHAREINFO0_PATCH
	PY_NETSHAREINFO0_PATCH(&srvsvc_NetShareInfo0_Type);
#endif
#ifdef PY_NETSHARECTR0_PATCH
	PY_NETSHARECTR0_PATCH(&srvsvc_NetShareCtr0_Type);
#endif
#ifdef PY_NETSHAREINFO1_PATCH
	PY_NETSHAREINFO1_PATCH(&srvsvc_NetShareInfo1_Type);
#endif
#ifdef PY_NETSHARECTR1_PATCH
	PY_NETSHARECTR1_PATCH(&srvsvc_NetShareCtr1_Type);
#endif
#ifdef PY_NETSHAREINFO2_PATCH
	PY_NETSHAREINFO2_PATCH(&srvsvc_NetShareInfo2_Type);
#endif
#ifdef PY_NETSHARECTR2_PATCH
	PY_NETSHARECTR2_PATCH(&srvsvc_NetShareCtr2_Type);
#endif
#ifdef PY_NETSHAREINFO501_PATCH
	PY_NETSHAREINFO501_PATCH(&srvsvc_NetShareInfo501_Type);
#endif
#ifdef PY_NETSHARECTR501_PATCH
	PY_NETSHARECTR501_PATCH(&srvsvc_NetShareCtr501_Type);
#endif
#ifdef PY_NETSHAREINFO502_PATCH
	PY_NETSHAREINFO502_PATCH(&srvsvc_NetShareInfo502_Type);
#endif
#ifdef PY_NETSHARECTR502_PATCH
	PY_NETSHARECTR502_PATCH(&srvsvc_NetShareCtr502_Type);
#endif
#ifdef PY_NETSHAREINFO1004_PATCH
	PY_NETSHAREINFO1004_PATCH(&srvsvc_NetShareInfo1004_Type);
#endif
#ifdef PY_NETSHARECTR1004_PATCH
	PY_NETSHARECTR1004_PATCH(&srvsvc_NetShareCtr1004_Type);
#endif
#ifdef PY_NETSHAREINFO1005_PATCH
	PY_NETSHAREINFO1005_PATCH(&srvsvc_NetShareInfo1005_Type);
#endif
#ifdef PY_NETSHARECTR1005_PATCH
	PY_NETSHARECTR1005_PATCH(&srvsvc_NetShareCtr1005_Type);
#endif
#ifdef PY_NETSHAREINFO1006_PATCH
	PY_NETSHAREINFO1006_PATCH(&srvsvc_NetShareInfo1006_Type);
#endif
#ifdef PY_NETSHARECTR1006_PATCH
	PY_NETSHARECTR1006_PATCH(&srvsvc_NetShareCtr1006_Type);
#endif
#ifdef PY_NETSHAREINFO1007_PATCH
	PY_NETSHAREINFO1007_PATCH(&srvsvc_NetShareInfo1007_Type);
#endif
#ifdef PY_NETSHARECTR1007_PATCH
	PY_NETSHARECTR1007_PATCH(&srvsvc_NetShareCtr1007_Type);
#endif
#ifdef PY_NETSHARECTR1501_PATCH
	PY_NETSHARECTR1501_PATCH(&srvsvc_NetShareCtr1501_Type);
#endif
#ifdef PY_NETSHAREINFOCTR_PATCH
	PY_NETSHAREINFOCTR_PATCH(&srvsvc_NetShareInfoCtr_Type);
#endif
#ifdef PY_NETSRVINFO100_PATCH
	PY_NETSRVINFO100_PATCH(&srvsvc_NetSrvInfo100_Type);
#endif
#ifdef PY_NETSRVINFO101_PATCH
	PY_NETSRVINFO101_PATCH(&srvsvc_NetSrvInfo101_Type);
#endif
#ifdef PY_NETSRVINFO102_PATCH
	PY_NETSRVINFO102_PATCH(&srvsvc_NetSrvInfo102_Type);
#endif
#ifdef PY_NETSRVINFO402_PATCH
	PY_NETSRVINFO402_PATCH(&srvsvc_NetSrvInfo402_Type);
#endif
#ifdef PY_NETSRVINFO403_PATCH
	PY_NETSRVINFO403_PATCH(&srvsvc_NetSrvInfo403_Type);
#endif
#ifdef PY_NETSRVINFO502_PATCH
	PY_NETSRVINFO502_PATCH(&srvsvc_NetSrvInfo502_Type);
#endif
#ifdef PY_NETSRVINFO503_PATCH
	PY_NETSRVINFO503_PATCH(&srvsvc_NetSrvInfo503_Type);
#endif
#ifdef PY_NETSRVINFO599_PATCH
	PY_NETSRVINFO599_PATCH(&srvsvc_NetSrvInfo599_Type);
#endif
#ifdef PY_NETSRVINFO1005_PATCH
	PY_NETSRVINFO1005_PATCH(&srvsvc_NetSrvInfo1005_Type);
#endif
#ifdef PY_NETSRVINFO1010_PATCH
	PY_NETSRVINFO1010_PATCH(&srvsvc_NetSrvInfo1010_Type);
#endif
#ifdef PY_NETSRVINFO1016_PATCH
	PY_NETSRVINFO1016_PATCH(&srvsvc_NetSrvInfo1016_Type);
#endif
#ifdef PY_NETSRVINFO1017_PATCH
	PY_NETSRVINFO1017_PATCH(&srvsvc_NetSrvInfo1017_Type);
#endif
#ifdef PY_NETSRVINFO1018_PATCH
	PY_NETSRVINFO1018_PATCH(&srvsvc_NetSrvInfo1018_Type);
#endif
#ifdef PY_NETSRVINFO1107_PATCH
	PY_NETSRVINFO1107_PATCH(&srvsvc_NetSrvInfo1107_Type);
#endif
#ifdef PY_NETSRVINFO1501_PATCH
	PY_NETSRVINFO1501_PATCH(&srvsvc_NetSrvInfo1501_Type);
#endif
#ifdef PY_NETSRVINFO1502_PATCH
	PY_NETSRVINFO1502_PATCH(&srvsvc_NetSrvInfo1502_Type);
#endif
#ifdef PY_NETSRVINFO1503_PATCH
	PY_NETSRVINFO1503_PATCH(&srvsvc_NetSrvInfo1503_Type);
#endif
#ifdef PY_NETSRVINFO1506_PATCH
	PY_NETSRVINFO1506_PATCH(&srvsvc_NetSrvInfo1506_Type);
#endif
#ifdef PY_NETSRVINFO1509_PATCH
	PY_NETSRVINFO1509_PATCH(&srvsvc_NetSrvInfo1509_Type);
#endif
#ifdef PY_NETSRVINFO1510_PATCH
	PY_NETSRVINFO1510_PATCH(&srvsvc_NetSrvInfo1510_Type);
#endif
#ifdef PY_NETSRVINFO1511_PATCH
	PY_NETSRVINFO1511_PATCH(&srvsvc_NetSrvInfo1511_Type);
#endif
#ifdef PY_NETSRVINFO1512_PATCH
	PY_NETSRVINFO1512_PATCH(&srvsvc_NetSrvInfo1512_Type);
#endif
#ifdef PY_NETSRVINFO1513_PATCH
	PY_NETSRVINFO1513_PATCH(&srvsvc_NetSrvInfo1513_Type);
#endif
#ifdef PY_NETSRVINFO1514_PATCH
	PY_NETSRVINFO1514_PATCH(&srvsvc_NetSrvInfo1514_Type);
#endif
#ifdef PY_NETSRVINFO1515_PATCH
	PY_NETSRVINFO1515_PATCH(&srvsvc_NetSrvInfo1515_Type);
#endif
#ifdef PY_NETSRVINFO1516_PATCH
	PY_NETSRVINFO1516_PATCH(&srvsvc_NetSrvInfo1516_Type);
#endif
#ifdef PY_NETSRVINFO1518_PATCH
	PY_NETSRVINFO1518_PATCH(&srvsvc_NetSrvInfo1518_Type);
#endif
#ifdef PY_NETSRVINFO1520_PATCH
	PY_NETSRVINFO1520_PATCH(&srvsvc_NetSrvInfo1520_Type);
#endif
#ifdef PY_NETSRVINFO1521_PATCH
	PY_NETSRVINFO1521_PATCH(&srvsvc_NetSrvInfo1521_Type);
#endif
#ifdef PY_NETSRVINFO1522_PATCH
	PY_NETSRVINFO1522_PATCH(&srvsvc_NetSrvInfo1522_Type);
#endif
#ifdef PY_NETSRVINFO1523_PATCH
	PY_NETSRVINFO1523_PATCH(&srvsvc_NetSrvInfo1523_Type);
#endif
#ifdef PY_NETSRVINFO1524_PATCH
	PY_NETSRVINFO1524_PATCH(&srvsvc_NetSrvInfo1524_Type);
#endif
#ifdef PY_NETSRVINFO1525_PATCH
	PY_NETSRVINFO1525_PATCH(&srvsvc_NetSrvInfo1525_Type);
#endif
#ifdef PY_NETSRVINFO1528_PATCH
	PY_NETSRVINFO1528_PATCH(&srvsvc_NetSrvInfo1528_Type);
#endif
#ifdef PY_NETSRVINFO1529_PATCH
	PY_NETSRVINFO1529_PATCH(&srvsvc_NetSrvInfo1529_Type);
#endif
#ifdef PY_NETSRVINFO1530_PATCH
	PY_NETSRVINFO1530_PATCH(&srvsvc_NetSrvInfo1530_Type);
#endif
#ifdef PY_NETSRVINFO1533_PATCH
	PY_NETSRVINFO1533_PATCH(&srvsvc_NetSrvInfo1533_Type);
#endif
#ifdef PY_NETSRVINFO1534_PATCH
	PY_NETSRVINFO1534_PATCH(&srvsvc_NetSrvInfo1534_Type);
#endif
#ifdef PY_NETSRVINFO1535_PATCH
	PY_NETSRVINFO1535_PATCH(&srvsvc_NetSrvInfo1535_Type);
#endif
#ifdef PY_NETSRVINFO1536_PATCH
	PY_NETSRVINFO1536_PATCH(&srvsvc_NetSrvInfo1536_Type);
#endif
#ifdef PY_NETSRVINFO1537_PATCH
	PY_NETSRVINFO1537_PATCH(&srvsvc_NetSrvInfo1537_Type);
#endif
#ifdef PY_NETSRVINFO1538_PATCH
	PY_NETSRVINFO1538_PATCH(&srvsvc_NetSrvInfo1538_Type);
#endif
#ifdef PY_NETSRVINFO1539_PATCH
	PY_NETSRVINFO1539_PATCH(&srvsvc_NetSrvInfo1539_Type);
#endif
#ifdef PY_NETSRVINFO1540_PATCH
	PY_NETSRVINFO1540_PATCH(&srvsvc_NetSrvInfo1540_Type);
#endif
#ifdef PY_NETSRVINFO1541_PATCH
	PY_NETSRVINFO1541_PATCH(&srvsvc_NetSrvInfo1541_Type);
#endif
#ifdef PY_NETSRVINFO1542_PATCH
	PY_NETSRVINFO1542_PATCH(&srvsvc_NetSrvInfo1542_Type);
#endif
#ifdef PY_NETSRVINFO1543_PATCH
	PY_NETSRVINFO1543_PATCH(&srvsvc_NetSrvInfo1543_Type);
#endif
#ifdef PY_NETSRVINFO1544_PATCH
	PY_NETSRVINFO1544_PATCH(&srvsvc_NetSrvInfo1544_Type);
#endif
#ifdef PY_NETSRVINFO1545_PATCH
	PY_NETSRVINFO1545_PATCH(&srvsvc_NetSrvInfo1545_Type);
#endif
#ifdef PY_NETSRVINFO1546_PATCH
	PY_NETSRVINFO1546_PATCH(&srvsvc_NetSrvInfo1546_Type);
#endif
#ifdef PY_NETSRVINFO1547_PATCH
	PY_NETSRVINFO1547_PATCH(&srvsvc_NetSrvInfo1547_Type);
#endif
#ifdef PY_NETSRVINFO1548_PATCH
	PY_NETSRVINFO1548_PATCH(&srvsvc_NetSrvInfo1548_Type);
#endif
#ifdef PY_NETSRVINFO1549_PATCH
	PY_NETSRVINFO1549_PATCH(&srvsvc_NetSrvInfo1549_Type);
#endif
#ifdef PY_NETSRVINFO1550_PATCH
	PY_NETSRVINFO1550_PATCH(&srvsvc_NetSrvInfo1550_Type);
#endif
#ifdef PY_NETSRVINFO1552_PATCH
	PY_NETSRVINFO1552_PATCH(&srvsvc_NetSrvInfo1552_Type);
#endif
#ifdef PY_NETSRVINFO1553_PATCH
	PY_NETSRVINFO1553_PATCH(&srvsvc_NetSrvInfo1553_Type);
#endif
#ifdef PY_NETSRVINFO1554_PATCH
	PY_NETSRVINFO1554_PATCH(&srvsvc_NetSrvInfo1554_Type);
#endif
#ifdef PY_NETSRVINFO1555_PATCH
	PY_NETSRVINFO1555_PATCH(&srvsvc_NetSrvInfo1555_Type);
#endif
#ifdef PY_NETSRVINFO1556_PATCH
	PY_NETSRVINFO1556_PATCH(&srvsvc_NetSrvInfo1556_Type);
#endif
#ifdef PY_NETDISKINFO0_PATCH
	PY_NETDISKINFO0_PATCH(&srvsvc_NetDiskInfo0_Type);
#endif
#ifdef PY_NETDISKINFO_PATCH
	PY_NETDISKINFO_PATCH(&srvsvc_NetDiskInfo_Type);
#endif
#ifdef PY_STATISTICS_PATCH
	PY_STATISTICS_PATCH(&srvsvc_Statistics_Type);
#endif
#ifdef PY_NETTRANSPORTINFO0_PATCH
	PY_NETTRANSPORTINFO0_PATCH(&srvsvc_NetTransportInfo0_Type);
#endif
#ifdef PY_NETTRANSPORTCTR0_PATCH
	PY_NETTRANSPORTCTR0_PATCH(&srvsvc_NetTransportCtr0_Type);
#endif
#ifdef PY_NETTRANSPORTINFO1_PATCH
	PY_NETTRANSPORTINFO1_PATCH(&srvsvc_NetTransportInfo1_Type);
#endif
#ifdef PY_NETTRANSPORTCTR1_PATCH
	PY_NETTRANSPORTCTR1_PATCH(&srvsvc_NetTransportCtr1_Type);
#endif
#ifdef PY_NETTRANSPORTINFO2_PATCH
	PY_NETTRANSPORTINFO2_PATCH(&srvsvc_NetTransportInfo2_Type);
#endif
#ifdef PY_NETTRANSPORTCTR2_PATCH
	PY_NETTRANSPORTCTR2_PATCH(&srvsvc_NetTransportCtr2_Type);
#endif
#ifdef PY_NETTRANSPORTINFO3_PATCH
	PY_NETTRANSPORTINFO3_PATCH(&srvsvc_NetTransportInfo3_Type);
#endif
#ifdef PY_NETTRANSPORTCTR3_PATCH
	PY_NETTRANSPORTCTR3_PATCH(&srvsvc_NetTransportCtr3_Type);
#endif
#ifdef PY_NETTRANSPORTINFOCTR_PATCH
	PY_NETTRANSPORTINFOCTR_PATCH(&srvsvc_NetTransportInfoCtr_Type);
#endif
#ifdef PY_NETREMOTETODINFO_PATCH
	PY_NETREMOTETODINFO_PATCH(&srvsvc_NetRemoteTODInfo_Type);
#endif
#ifdef PY_SRVSVC_PATCH
	PY_SRVSVC_PATCH(&srvsvc_InterfaceType);
#endif

	m = Py_InitModule3("srvsvc", srvsvc_methods, "srvsvc DCE/RPC");
	if (m == NULL)
		return;

	PyModule_AddObject(m, "SHARE_1005_IN_DFS", PyInt_FromLong(SHARE_1005_IN_DFS));
	PyModule_AddObject(m, "STYPE_DEVICE", PyInt_FromLong(STYPE_DEVICE));
	PyModule_AddObject(m, "PLATFORM_ID_NT", PyInt_FromLong(PLATFORM_ID_NT));
	PyModule_AddObject(m, "STYPE_IPC_TEMPORARY", PyInt_FromLong(STYPE_IPC_TEMPORARY));
	PyModule_AddObject(m, "STYPE_HIDDEN", PyInt_FromLong(0x80000000));
	PyModule_AddObject(m, "STYPE_PRINTQ", PyInt_FromLong(STYPE_PRINTQ));
	PyModule_AddObject(m, "STYPE_TEMPORARY", PyInt_FromLong(0x40000000));
	PyModule_AddObject(m, "PLATFORM_ID_OSF", PyInt_FromLong(PLATFORM_ID_OSF));
	PyModule_AddObject(m, "STYPE_DISKTREE", PyInt_FromLong(STYPE_DISKTREE));
	PyModule_AddObject(m, "STYPE_DISKTREE_HIDDEN", PyInt_FromLong(STYPE_DISKTREE_HIDDEN));
	PyModule_AddObject(m, "PLATFORM_ID_VMS", PyInt_FromLong(PLATFORM_ID_VMS));
	PyModule_AddObject(m, "STYPE_IPC_HIDDEN", PyInt_FromLong(STYPE_IPC_HIDDEN));
	PyModule_AddObject(m, "SHARE_1005_DFS_ROOT", PyInt_FromLong(SHARE_1005_DFS_ROOT));
	PyModule_AddObject(m, "STYPE_PRINTQ_HIDDEN", PyInt_FromLong(STYPE_PRINTQ_HIDDEN));
	PyModule_AddObject(m, "STYPE_DEVICE_TEMPORARY", PyInt_FromLong(STYPE_DEVICE_TEMPORARY));
	PyModule_AddObject(m, "STYPE_IPC", PyInt_FromLong(STYPE_IPC));
	PyModule_AddObject(m, "SHARE_1005_CSC_POLICY_MASK", PyInt_FromLong(0x00000030));
	PyModule_AddObject(m, "STYPE_PRINTQ_TEMPORARY", PyInt_FromLong(STYPE_PRINTQ_TEMPORARY));
	PyModule_AddObject(m, "STYPE_DEVICE_HIDDEN", PyInt_FromLong(STYPE_DEVICE_HIDDEN));
	PyModule_AddObject(m, "STYPE_DISKTREE_TEMPORARY", PyInt_FromLong(STYPE_DISKTREE_TEMPORARY));
	PyModule_AddObject(m, "PLATFORM_ID_OS2", PyInt_FromLong(PLATFORM_ID_OS2));
	PyModule_AddObject(m, "SHARE_1005_CSC_POLICY_SHIFT", PyInt_FromLong(4));
	PyModule_AddObject(m, "PLATFORM_ID_DOS", PyInt_FromLong(PLATFORM_ID_DOS));
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfo0_Type);
	PyModule_AddObject(m, "NetCharDevInfo0", (PyObject *)(void *)&srvsvc_NetCharDevInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevCtr0_Type);
	PyModule_AddObject(m, "NetCharDevCtr0", (PyObject *)(void *)&srvsvc_NetCharDevCtr0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfo1_Type);
	PyModule_AddObject(m, "NetCharDevInfo1", (PyObject *)(void *)&srvsvc_NetCharDevInfo1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevCtr1_Type);
	PyModule_AddObject(m, "NetCharDevCtr1", (PyObject *)(void *)&srvsvc_NetCharDevCtr1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfoCtr_Type);
	PyModule_AddObject(m, "NetCharDevInfoCtr", (PyObject *)(void *)&srvsvc_NetCharDevInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfo0_Type);
	PyModule_AddObject(m, "NetCharDevQInfo0", (PyObject *)(void *)&srvsvc_NetCharDevQInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQCtr0_Type);
	PyModule_AddObject(m, "NetCharDevQCtr0", (PyObject *)(void *)&srvsvc_NetCharDevQCtr0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfo1_Type);
	PyModule_AddObject(m, "NetCharDevQInfo1", (PyObject *)(void *)&srvsvc_NetCharDevQInfo1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQCtr1_Type);
	PyModule_AddObject(m, "NetCharDevQCtr1", (PyObject *)(void *)&srvsvc_NetCharDevQCtr1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfoCtr_Type);
	PyModule_AddObject(m, "NetCharDevQInfoCtr", (PyObject *)(void *)&srvsvc_NetCharDevQInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfo0_Type);
	PyModule_AddObject(m, "NetConnInfo0", (PyObject *)(void *)&srvsvc_NetConnInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetConnCtr0_Type);
	PyModule_AddObject(m, "NetConnCtr0", (PyObject *)(void *)&srvsvc_NetConnCtr0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfo1_Type);
	PyModule_AddObject(m, "NetConnInfo1", (PyObject *)(void *)&srvsvc_NetConnInfo1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetConnCtr1_Type);
	PyModule_AddObject(m, "NetConnCtr1", (PyObject *)(void *)&srvsvc_NetConnCtr1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfoCtr_Type);
	PyModule_AddObject(m, "NetConnInfoCtr", (PyObject *)(void *)&srvsvc_NetConnInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfo2_Type);
	PyModule_AddObject(m, "NetFileInfo2", (PyObject *)(void *)&srvsvc_NetFileInfo2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetFileCtr2_Type);
	PyModule_AddObject(m, "NetFileCtr2", (PyObject *)(void *)&srvsvc_NetFileCtr2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfo3_Type);
	PyModule_AddObject(m, "NetFileInfo3", (PyObject *)(void *)&srvsvc_NetFileInfo3_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetFileCtr3_Type);
	PyModule_AddObject(m, "NetFileCtr3", (PyObject *)(void *)&srvsvc_NetFileCtr3_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfoCtr_Type);
	PyModule_AddObject(m, "NetFileInfoCtr", (PyObject *)(void *)&srvsvc_NetFileInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo0_Type);
	PyModule_AddObject(m, "NetSessInfo0", (PyObject *)(void *)&srvsvc_NetSessInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr0_Type);
	PyModule_AddObject(m, "NetSessCtr0", (PyObject *)(void *)&srvsvc_NetSessCtr0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo1_Type);
	PyModule_AddObject(m, "NetSessInfo1", (PyObject *)(void *)&srvsvc_NetSessInfo1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr1_Type);
	PyModule_AddObject(m, "NetSessCtr1", (PyObject *)(void *)&srvsvc_NetSessCtr1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo2_Type);
	PyModule_AddObject(m, "NetSessInfo2", (PyObject *)(void *)&srvsvc_NetSessInfo2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr2_Type);
	PyModule_AddObject(m, "NetSessCtr2", (PyObject *)(void *)&srvsvc_NetSessCtr2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo10_Type);
	PyModule_AddObject(m, "NetSessInfo10", (PyObject *)(void *)&srvsvc_NetSessInfo10_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr10_Type);
	PyModule_AddObject(m, "NetSessCtr10", (PyObject *)(void *)&srvsvc_NetSessCtr10_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo502_Type);
	PyModule_AddObject(m, "NetSessInfo502", (PyObject *)(void *)&srvsvc_NetSessInfo502_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr502_Type);
	PyModule_AddObject(m, "NetSessCtr502", (PyObject *)(void *)&srvsvc_NetSessCtr502_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfoCtr_Type);
	PyModule_AddObject(m, "NetSessInfoCtr", (PyObject *)(void *)&srvsvc_NetSessInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo0_Type);
	PyModule_AddObject(m, "NetShareInfo0", (PyObject *)(void *)&srvsvc_NetShareInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr0_Type);
	PyModule_AddObject(m, "NetShareCtr0", (PyObject *)(void *)&srvsvc_NetShareCtr0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1_Type);
	PyModule_AddObject(m, "NetShareInfo1", (PyObject *)(void *)&srvsvc_NetShareInfo1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1_Type);
	PyModule_AddObject(m, "NetShareCtr1", (PyObject *)(void *)&srvsvc_NetShareCtr1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo2_Type);
	PyModule_AddObject(m, "NetShareInfo2", (PyObject *)(void *)&srvsvc_NetShareInfo2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr2_Type);
	PyModule_AddObject(m, "NetShareCtr2", (PyObject *)(void *)&srvsvc_NetShareCtr2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo501_Type);
	PyModule_AddObject(m, "NetShareInfo501", (PyObject *)(void *)&srvsvc_NetShareInfo501_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr501_Type);
	PyModule_AddObject(m, "NetShareCtr501", (PyObject *)(void *)&srvsvc_NetShareCtr501_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo502_Type);
	PyModule_AddObject(m, "NetShareInfo502", (PyObject *)(void *)&srvsvc_NetShareInfo502_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr502_Type);
	PyModule_AddObject(m, "NetShareCtr502", (PyObject *)(void *)&srvsvc_NetShareCtr502_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1004_Type);
	PyModule_AddObject(m, "NetShareInfo1004", (PyObject *)(void *)&srvsvc_NetShareInfo1004_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1004_Type);
	PyModule_AddObject(m, "NetShareCtr1004", (PyObject *)(void *)&srvsvc_NetShareCtr1004_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1005_Type);
	PyModule_AddObject(m, "NetShareInfo1005", (PyObject *)(void *)&srvsvc_NetShareInfo1005_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1005_Type);
	PyModule_AddObject(m, "NetShareCtr1005", (PyObject *)(void *)&srvsvc_NetShareCtr1005_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1006_Type);
	PyModule_AddObject(m, "NetShareInfo1006", (PyObject *)(void *)&srvsvc_NetShareInfo1006_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1006_Type);
	PyModule_AddObject(m, "NetShareCtr1006", (PyObject *)(void *)&srvsvc_NetShareCtr1006_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1007_Type);
	PyModule_AddObject(m, "NetShareInfo1007", (PyObject *)(void *)&srvsvc_NetShareInfo1007_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1007_Type);
	PyModule_AddObject(m, "NetShareCtr1007", (PyObject *)(void *)&srvsvc_NetShareCtr1007_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1501_Type);
	PyModule_AddObject(m, "NetShareCtr1501", (PyObject *)(void *)&srvsvc_NetShareCtr1501_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfoCtr_Type);
	PyModule_AddObject(m, "NetShareInfoCtr", (PyObject *)(void *)&srvsvc_NetShareInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo100_Type);
	PyModule_AddObject(m, "NetSrvInfo100", (PyObject *)(void *)&srvsvc_NetSrvInfo100_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo101_Type);
	PyModule_AddObject(m, "NetSrvInfo101", (PyObject *)(void *)&srvsvc_NetSrvInfo101_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo102_Type);
	PyModule_AddObject(m, "NetSrvInfo102", (PyObject *)(void *)&srvsvc_NetSrvInfo102_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo402_Type);
	PyModule_AddObject(m, "NetSrvInfo402", (PyObject *)(void *)&srvsvc_NetSrvInfo402_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo403_Type);
	PyModule_AddObject(m, "NetSrvInfo403", (PyObject *)(void *)&srvsvc_NetSrvInfo403_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo502_Type);
	PyModule_AddObject(m, "NetSrvInfo502", (PyObject *)(void *)&srvsvc_NetSrvInfo502_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo503_Type);
	PyModule_AddObject(m, "NetSrvInfo503", (PyObject *)(void *)&srvsvc_NetSrvInfo503_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo599_Type);
	PyModule_AddObject(m, "NetSrvInfo599", (PyObject *)(void *)&srvsvc_NetSrvInfo599_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1005_Type);
	PyModule_AddObject(m, "NetSrvInfo1005", (PyObject *)(void *)&srvsvc_NetSrvInfo1005_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1010_Type);
	PyModule_AddObject(m, "NetSrvInfo1010", (PyObject *)(void *)&srvsvc_NetSrvInfo1010_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1016_Type);
	PyModule_AddObject(m, "NetSrvInfo1016", (PyObject *)(void *)&srvsvc_NetSrvInfo1016_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1017_Type);
	PyModule_AddObject(m, "NetSrvInfo1017", (PyObject *)(void *)&srvsvc_NetSrvInfo1017_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1018_Type);
	PyModule_AddObject(m, "NetSrvInfo1018", (PyObject *)(void *)&srvsvc_NetSrvInfo1018_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1107_Type);
	PyModule_AddObject(m, "NetSrvInfo1107", (PyObject *)(void *)&srvsvc_NetSrvInfo1107_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1501_Type);
	PyModule_AddObject(m, "NetSrvInfo1501", (PyObject *)(void *)&srvsvc_NetSrvInfo1501_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1502_Type);
	PyModule_AddObject(m, "NetSrvInfo1502", (PyObject *)(void *)&srvsvc_NetSrvInfo1502_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1503_Type);
	PyModule_AddObject(m, "NetSrvInfo1503", (PyObject *)(void *)&srvsvc_NetSrvInfo1503_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1506_Type);
	PyModule_AddObject(m, "NetSrvInfo1506", (PyObject *)(void *)&srvsvc_NetSrvInfo1506_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1509_Type);
	PyModule_AddObject(m, "NetSrvInfo1509", (PyObject *)(void *)&srvsvc_NetSrvInfo1509_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1510_Type);
	PyModule_AddObject(m, "NetSrvInfo1510", (PyObject *)(void *)&srvsvc_NetSrvInfo1510_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1511_Type);
	PyModule_AddObject(m, "NetSrvInfo1511", (PyObject *)(void *)&srvsvc_NetSrvInfo1511_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1512_Type);
	PyModule_AddObject(m, "NetSrvInfo1512", (PyObject *)(void *)&srvsvc_NetSrvInfo1512_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1513_Type);
	PyModule_AddObject(m, "NetSrvInfo1513", (PyObject *)(void *)&srvsvc_NetSrvInfo1513_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1514_Type);
	PyModule_AddObject(m, "NetSrvInfo1514", (PyObject *)(void *)&srvsvc_NetSrvInfo1514_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1515_Type);
	PyModule_AddObject(m, "NetSrvInfo1515", (PyObject *)(void *)&srvsvc_NetSrvInfo1515_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1516_Type);
	PyModule_AddObject(m, "NetSrvInfo1516", (PyObject *)(void *)&srvsvc_NetSrvInfo1516_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1518_Type);
	PyModule_AddObject(m, "NetSrvInfo1518", (PyObject *)(void *)&srvsvc_NetSrvInfo1518_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1520_Type);
	PyModule_AddObject(m, "NetSrvInfo1520", (PyObject *)(void *)&srvsvc_NetSrvInfo1520_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1521_Type);
	PyModule_AddObject(m, "NetSrvInfo1521", (PyObject *)(void *)&srvsvc_NetSrvInfo1521_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1522_Type);
	PyModule_AddObject(m, "NetSrvInfo1522", (PyObject *)(void *)&srvsvc_NetSrvInfo1522_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1523_Type);
	PyModule_AddObject(m, "NetSrvInfo1523", (PyObject *)(void *)&srvsvc_NetSrvInfo1523_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1524_Type);
	PyModule_AddObject(m, "NetSrvInfo1524", (PyObject *)(void *)&srvsvc_NetSrvInfo1524_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1525_Type);
	PyModule_AddObject(m, "NetSrvInfo1525", (PyObject *)(void *)&srvsvc_NetSrvInfo1525_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1528_Type);
	PyModule_AddObject(m, "NetSrvInfo1528", (PyObject *)(void *)&srvsvc_NetSrvInfo1528_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1529_Type);
	PyModule_AddObject(m, "NetSrvInfo1529", (PyObject *)(void *)&srvsvc_NetSrvInfo1529_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1530_Type);
	PyModule_AddObject(m, "NetSrvInfo1530", (PyObject *)(void *)&srvsvc_NetSrvInfo1530_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1533_Type);
	PyModule_AddObject(m, "NetSrvInfo1533", (PyObject *)(void *)&srvsvc_NetSrvInfo1533_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1534_Type);
	PyModule_AddObject(m, "NetSrvInfo1534", (PyObject *)(void *)&srvsvc_NetSrvInfo1534_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1535_Type);
	PyModule_AddObject(m, "NetSrvInfo1535", (PyObject *)(void *)&srvsvc_NetSrvInfo1535_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1536_Type);
	PyModule_AddObject(m, "NetSrvInfo1536", (PyObject *)(void *)&srvsvc_NetSrvInfo1536_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1537_Type);
	PyModule_AddObject(m, "NetSrvInfo1537", (PyObject *)(void *)&srvsvc_NetSrvInfo1537_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1538_Type);
	PyModule_AddObject(m, "NetSrvInfo1538", (PyObject *)(void *)&srvsvc_NetSrvInfo1538_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1539_Type);
	PyModule_AddObject(m, "NetSrvInfo1539", (PyObject *)(void *)&srvsvc_NetSrvInfo1539_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1540_Type);
	PyModule_AddObject(m, "NetSrvInfo1540", (PyObject *)(void *)&srvsvc_NetSrvInfo1540_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1541_Type);
	PyModule_AddObject(m, "NetSrvInfo1541", (PyObject *)(void *)&srvsvc_NetSrvInfo1541_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1542_Type);
	PyModule_AddObject(m, "NetSrvInfo1542", (PyObject *)(void *)&srvsvc_NetSrvInfo1542_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1543_Type);
	PyModule_AddObject(m, "NetSrvInfo1543", (PyObject *)(void *)&srvsvc_NetSrvInfo1543_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1544_Type);
	PyModule_AddObject(m, "NetSrvInfo1544", (PyObject *)(void *)&srvsvc_NetSrvInfo1544_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1545_Type);
	PyModule_AddObject(m, "NetSrvInfo1545", (PyObject *)(void *)&srvsvc_NetSrvInfo1545_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1546_Type);
	PyModule_AddObject(m, "NetSrvInfo1546", (PyObject *)(void *)&srvsvc_NetSrvInfo1546_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1547_Type);
	PyModule_AddObject(m, "NetSrvInfo1547", (PyObject *)(void *)&srvsvc_NetSrvInfo1547_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1548_Type);
	PyModule_AddObject(m, "NetSrvInfo1548", (PyObject *)(void *)&srvsvc_NetSrvInfo1548_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1549_Type);
	PyModule_AddObject(m, "NetSrvInfo1549", (PyObject *)(void *)&srvsvc_NetSrvInfo1549_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1550_Type);
	PyModule_AddObject(m, "NetSrvInfo1550", (PyObject *)(void *)&srvsvc_NetSrvInfo1550_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1552_Type);
	PyModule_AddObject(m, "NetSrvInfo1552", (PyObject *)(void *)&srvsvc_NetSrvInfo1552_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1553_Type);
	PyModule_AddObject(m, "NetSrvInfo1553", (PyObject *)(void *)&srvsvc_NetSrvInfo1553_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1554_Type);
	PyModule_AddObject(m, "NetSrvInfo1554", (PyObject *)(void *)&srvsvc_NetSrvInfo1554_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1555_Type);
	PyModule_AddObject(m, "NetSrvInfo1555", (PyObject *)(void *)&srvsvc_NetSrvInfo1555_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1556_Type);
	PyModule_AddObject(m, "NetSrvInfo1556", (PyObject *)(void *)&srvsvc_NetSrvInfo1556_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetDiskInfo0_Type);
	PyModule_AddObject(m, "NetDiskInfo0", (PyObject *)(void *)&srvsvc_NetDiskInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetDiskInfo_Type);
	PyModule_AddObject(m, "NetDiskInfo", (PyObject *)(void *)&srvsvc_NetDiskInfo_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_Statistics_Type);
	PyModule_AddObject(m, "Statistics", (PyObject *)(void *)&srvsvc_Statistics_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo0_Type);
	PyModule_AddObject(m, "NetTransportInfo0", (PyObject *)(void *)&srvsvc_NetTransportInfo0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr0_Type);
	PyModule_AddObject(m, "NetTransportCtr0", (PyObject *)(void *)&srvsvc_NetTransportCtr0_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo1_Type);
	PyModule_AddObject(m, "NetTransportInfo1", (PyObject *)(void *)&srvsvc_NetTransportInfo1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr1_Type);
	PyModule_AddObject(m, "NetTransportCtr1", (PyObject *)(void *)&srvsvc_NetTransportCtr1_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo2_Type);
	PyModule_AddObject(m, "NetTransportInfo2", (PyObject *)(void *)&srvsvc_NetTransportInfo2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr2_Type);
	PyModule_AddObject(m, "NetTransportCtr2", (PyObject *)(void *)&srvsvc_NetTransportCtr2_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo3_Type);
	PyModule_AddObject(m, "NetTransportInfo3", (PyObject *)(void *)&srvsvc_NetTransportInfo3_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr3_Type);
	PyModule_AddObject(m, "NetTransportCtr3", (PyObject *)(void *)&srvsvc_NetTransportCtr3_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfoCtr_Type);
	PyModule_AddObject(m, "NetTransportInfoCtr", (PyObject *)(void *)&srvsvc_NetTransportInfoCtr_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_NetRemoteTODInfo_Type);
	PyModule_AddObject(m, "NetRemoteTODInfo", (PyObject *)(void *)&srvsvc_NetRemoteTODInfo_Type);
	Py_INCREF((PyObject *)(void *)&srvsvc_InterfaceType);
	PyModule_AddObject(m, "srvsvc", (PyObject *)(void *)&srvsvc_InterfaceType);
#ifdef PY_MOD_SRVSVC_PATCH
	PY_MOD_SRVSVC_PATCH(m);
#endif

}
