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

#include "librpc/gen_ndr/srvsvc.h"
#include "librpc/gen_ndr/lsa.h"
staticforward PyTypeObject wkssvc_NetWkstaInfo100_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo101_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo102_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo502_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1010_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1011_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1012_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1013_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1018_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1023_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1027_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1028_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1032_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1033_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1041_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1042_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1043_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1044_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1045_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1046_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1047_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1048_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1049_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1050_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1051_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1052_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1053_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1054_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1055_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1056_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1057_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1058_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1059_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1060_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1061_Type;
staticforward PyTypeObject wkssvc_NetWkstaInfo1062_Type;
staticforward PyTypeObject wkssvc_NetrWkstaUserInfo0_Type;
staticforward PyTypeObject wkssvc_NetWkstaEnumUsersCtr0_Type;
staticforward PyTypeObject wkssvc_NetrWkstaUserInfo1_Type;
staticforward PyTypeObject wkssvc_NetWkstaEnumUsersCtr1_Type;
staticforward PyTypeObject wkssvc_NetWkstaEnumUsersInfo_Type;
staticforward PyTypeObject wkssvc_NetrWkstaUserInfo1101_Type;
staticforward PyTypeObject wkssvc_NetWkstaTransportInfo0_Type;
staticforward PyTypeObject wkssvc_NetWkstaTransportCtr0_Type;
staticforward PyTypeObject wkssvc_NetWkstaTransportInfo_Type;
staticforward PyTypeObject wkssvc_NetrUseInfo3_Type;
staticforward PyTypeObject wkssvc_NetrUseInfo2_Type;
staticforward PyTypeObject wkssvc_NetrUseInfo1_Type;
staticforward PyTypeObject wkssvc_NetrUseInfo0_Type;
staticforward PyTypeObject wkssvc_NetrUseEnumCtr2_Type;
staticforward PyTypeObject wkssvc_NetrUseEnumCtr1_Type;
staticforward PyTypeObject wkssvc_NetrUseEnumCtr0_Type;
staticforward PyTypeObject wkssvc_NetrUseEnumInfo_Type;
staticforward PyTypeObject wkssvc_NetrWorkstationStatistics_Type;
staticforward PyTypeObject wkssvc_PasswordBuffer_Type;
staticforward PyTypeObject wkssvc_ComputerNamesCtr_Type;
staticforward PyTypeObject wkssvc_InterfaceType;

void initwkssvc(void);static PyTypeObject *lsa_String_Type;
static PyTypeObject *Object_Type;
static PyTypeObject *ClientConnection_Type;

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

static int py_wkssvc_NetWkstaInfo100_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaInfo100 *object = (struct wkssvc_NetWkstaInfo100 *)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_wkssvc_NetWkstaInfo100_get_server_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo100 *object = (struct wkssvc_NetWkstaInfo100 *)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_wkssvc_NetWkstaInfo100_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaInfo100 *object = (struct wkssvc_NetWkstaInfo100 *)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_wkssvc_NetWkstaInfo100_get_domain_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo100 *object = (struct wkssvc_NetWkstaInfo100 *)pytalloc_get_ptr(obj);
	PyObject *py_domain_name;
	if (object->domain_name == NULL) {
		py_domain_name = Py_None;
		Py_INCREF(py_domain_name);
	} else {
		if (object->domain_name == NULL) {
			py_domain_name = Py_None;
			Py_INCREF(py_domain_name);
		} else {
			py_domain_name = PyUnicode_Decode(object->domain_name, strlen(object->domain_name), "utf-8", "ignore");
		}
	}
	return py_domain_name;
}

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

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

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

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

static PyGetSetDef py_wkssvc_NetWkstaInfo100_getsetters[] = {
	{ discard_const_p(char, "platform_id"), py_wkssvc_NetWkstaInfo100_get_platform_id, py_wkssvc_NetWkstaInfo100_set_platform_id },
	{ discard_const_p(char, "server_name"), py_wkssvc_NetWkstaInfo100_get_server_name, py_wkssvc_NetWkstaInfo100_set_server_name },
	{ discard_const_p(char, "domain_name"), py_wkssvc_NetWkstaInfo100_get_domain_name, py_wkssvc_NetWkstaInfo100_set_domain_name },
	{ discard_const_p(char, "version_major"), py_wkssvc_NetWkstaInfo100_get_version_major, py_wkssvc_NetWkstaInfo100_set_version_major },
	{ discard_const_p(char, "version_minor"), py_wkssvc_NetWkstaInfo100_get_version_minor, py_wkssvc_NetWkstaInfo100_set_version_minor },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo100_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo100",
	.tp_getset = py_wkssvc_NetWkstaInfo100_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo100_new,
};


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

static int py_wkssvc_NetWkstaInfo101_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaInfo101 *object = (struct wkssvc_NetWkstaInfo101 *)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_wkssvc_NetWkstaInfo101_get_server_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo101 *object = (struct wkssvc_NetWkstaInfo101 *)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_wkssvc_NetWkstaInfo101_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaInfo101 *object = (struct wkssvc_NetWkstaInfo101 *)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_wkssvc_NetWkstaInfo101_get_domain_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo101 *object = (struct wkssvc_NetWkstaInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_domain_name;
	if (object->domain_name == NULL) {
		py_domain_name = Py_None;
		Py_INCREF(py_domain_name);
	} else {
		if (object->domain_name == NULL) {
			py_domain_name = Py_None;
			Py_INCREF(py_domain_name);
		} else {
			py_domain_name = PyUnicode_Decode(object->domain_name, strlen(object->domain_name), "utf-8", "ignore");
		}
	}
	return py_domain_name;
}

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

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

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

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

static PyObject *py_wkssvc_NetWkstaInfo101_get_lan_root(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo101 *object = (struct wkssvc_NetWkstaInfo101 *)pytalloc_get_ptr(obj);
	PyObject *py_lan_root;
	if (object->lan_root == NULL) {
		py_lan_root = Py_None;
		Py_INCREF(py_lan_root);
	} else {
		if (object->lan_root == NULL) {
			py_lan_root = Py_None;
			Py_INCREF(py_lan_root);
		} else {
			py_lan_root = PyUnicode_Decode(object->lan_root, strlen(object->lan_root), "utf-8", "ignore");
		}
	}
	return py_lan_root;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo101_getsetters[] = {
	{ discard_const_p(char, "platform_id"), py_wkssvc_NetWkstaInfo101_get_platform_id, py_wkssvc_NetWkstaInfo101_set_platform_id },
	{ discard_const_p(char, "server_name"), py_wkssvc_NetWkstaInfo101_get_server_name, py_wkssvc_NetWkstaInfo101_set_server_name },
	{ discard_const_p(char, "domain_name"), py_wkssvc_NetWkstaInfo101_get_domain_name, py_wkssvc_NetWkstaInfo101_set_domain_name },
	{ discard_const_p(char, "version_major"), py_wkssvc_NetWkstaInfo101_get_version_major, py_wkssvc_NetWkstaInfo101_set_version_major },
	{ discard_const_p(char, "version_minor"), py_wkssvc_NetWkstaInfo101_get_version_minor, py_wkssvc_NetWkstaInfo101_set_version_minor },
	{ discard_const_p(char, "lan_root"), py_wkssvc_NetWkstaInfo101_get_lan_root, py_wkssvc_NetWkstaInfo101_set_lan_root },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo101_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo101",
	.tp_getset = py_wkssvc_NetWkstaInfo101_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo101_new,
};


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

static int py_wkssvc_NetWkstaInfo102_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaInfo102 *object = (struct wkssvc_NetWkstaInfo102 *)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_wkssvc_NetWkstaInfo102_get_server_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo102 *object = (struct wkssvc_NetWkstaInfo102 *)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_wkssvc_NetWkstaInfo102_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaInfo102 *object = (struct wkssvc_NetWkstaInfo102 *)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_wkssvc_NetWkstaInfo102_get_domain_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo102 *object = (struct wkssvc_NetWkstaInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_domain_name;
	if (object->domain_name == NULL) {
		py_domain_name = Py_None;
		Py_INCREF(py_domain_name);
	} else {
		if (object->domain_name == NULL) {
			py_domain_name = Py_None;
			Py_INCREF(py_domain_name);
		} else {
			py_domain_name = PyUnicode_Decode(object->domain_name, strlen(object->domain_name), "utf-8", "ignore");
		}
	}
	return py_domain_name;
}

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

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

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

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

static PyObject *py_wkssvc_NetWkstaInfo102_get_lan_root(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo102 *object = (struct wkssvc_NetWkstaInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_lan_root;
	if (object->lan_root == NULL) {
		py_lan_root = Py_None;
		Py_INCREF(py_lan_root);
	} else {
		if (object->lan_root == NULL) {
			py_lan_root = Py_None;
			Py_INCREF(py_lan_root);
		} else {
			py_lan_root = PyUnicode_Decode(object->lan_root, strlen(object->lan_root), "utf-8", "ignore");
		}
	}
	return py_lan_root;
}

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

static PyObject *py_wkssvc_NetWkstaInfo102_get_logged_on_users(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo102 *object = (struct wkssvc_NetWkstaInfo102 *)pytalloc_get_ptr(obj);
	PyObject *py_logged_on_users;
	py_logged_on_users = PyInt_FromLong(object->logged_on_users);
	return py_logged_on_users;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo102_getsetters[] = {
	{ discard_const_p(char, "platform_id"), py_wkssvc_NetWkstaInfo102_get_platform_id, py_wkssvc_NetWkstaInfo102_set_platform_id },
	{ discard_const_p(char, "server_name"), py_wkssvc_NetWkstaInfo102_get_server_name, py_wkssvc_NetWkstaInfo102_set_server_name },
	{ discard_const_p(char, "domain_name"), py_wkssvc_NetWkstaInfo102_get_domain_name, py_wkssvc_NetWkstaInfo102_set_domain_name },
	{ discard_const_p(char, "version_major"), py_wkssvc_NetWkstaInfo102_get_version_major, py_wkssvc_NetWkstaInfo102_set_version_major },
	{ discard_const_p(char, "version_minor"), py_wkssvc_NetWkstaInfo102_get_version_minor, py_wkssvc_NetWkstaInfo102_set_version_minor },
	{ discard_const_p(char, "lan_root"), py_wkssvc_NetWkstaInfo102_get_lan_root, py_wkssvc_NetWkstaInfo102_set_lan_root },
	{ discard_const_p(char, "logged_on_users"), py_wkssvc_NetWkstaInfo102_get_logged_on_users, py_wkssvc_NetWkstaInfo102_set_logged_on_users },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo102_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo102",
	.tp_getset = py_wkssvc_NetWkstaInfo102_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo102_new,
};


static PyObject *py_wkssvc_NetWkstaInfo502_get_char_wait(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_char_wait;
	py_char_wait = PyInt_FromLong(object->char_wait);
	return py_char_wait;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_collection_time(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_collection_time;
	py_collection_time = PyInt_FromLong(object->collection_time);
	return py_collection_time;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_maximum_collection_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_maximum_collection_count;
	py_maximum_collection_count = PyInt_FromLong(object->maximum_collection_count);
	return py_maximum_collection_count;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_keep_connection(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_keep_connection;
	py_keep_connection = PyInt_FromLong(object->keep_connection);
	return py_keep_connection;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_max_commands(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_max_commands;
	py_max_commands = PyInt_FromLong(object->max_commands);
	return py_max_commands;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_session_timeout(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_session_timeout;
	py_session_timeout = PyInt_FromLong(object->session_timeout);
	return py_session_timeout;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_size_char_buf(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_size_char_buf;
	py_size_char_buf = PyInt_FromLong(object->size_char_buf);
	return py_size_char_buf;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_max_threads(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_max_threads;
	py_max_threads = PyInt_FromLong(object->max_threads);
	return py_max_threads;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_lock_quota(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_lock_quota;
	py_lock_quota = PyInt_FromLong(object->lock_quota);
	return py_lock_quota;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_lock_increment(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_lock_increment;
	py_lock_increment = PyInt_FromLong(object->lock_increment);
	return py_lock_increment;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_lock_maximum(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_lock_maximum;
	py_lock_maximum = PyInt_FromLong(object->lock_maximum);
	return py_lock_maximum;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_pipe_increment(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_pipe_increment;
	py_pipe_increment = PyInt_FromLong(object->pipe_increment);
	return py_pipe_increment;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_pipe_maximum(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_pipe_maximum;
	py_pipe_maximum = PyInt_FromLong(object->pipe_maximum);
	return py_pipe_maximum;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_cache_file_timeout(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_cache_file_timeout;
	py_cache_file_timeout = PyInt_FromLong(object->cache_file_timeout);
	return py_cache_file_timeout;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_dormant_file_limit(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_dormant_file_limit;
	py_dormant_file_limit = PyInt_FromLong(object->dormant_file_limit);
	return py_dormant_file_limit;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_read_ahead_throughput(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_read_ahead_throughput;
	py_read_ahead_throughput = PyInt_FromLong(object->read_ahead_throughput);
	return py_read_ahead_throughput;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_num_mailslot_buffers(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_num_mailslot_buffers;
	py_num_mailslot_buffers = PyInt_FromLong(object->num_mailslot_buffers);
	return py_num_mailslot_buffers;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_num_srv_announce_buffers(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_num_srv_announce_buffers;
	py_num_srv_announce_buffers = PyInt_FromLong(object->num_srv_announce_buffers);
	return py_num_srv_announce_buffers;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_max_illegal_dgram_events(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_max_illegal_dgram_events;
	py_max_illegal_dgram_events = PyInt_FromLong(object->max_illegal_dgram_events);
	return py_max_illegal_dgram_events;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_dgram_event_reset_freq(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_dgram_event_reset_freq;
	py_dgram_event_reset_freq = PyInt_FromLong(object->dgram_event_reset_freq);
	return py_dgram_event_reset_freq;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_log_election_packets(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_log_election_packets;
	py_log_election_packets = PyInt_FromLong(object->log_election_packets);
	return py_log_election_packets;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_opportunistic_locking(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_opportunistic_locking;
	py_use_opportunistic_locking = PyInt_FromLong(object->use_opportunistic_locking);
	return py_use_opportunistic_locking;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_unlock_behind(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_unlock_behind;
	py_use_unlock_behind = PyInt_FromLong(object->use_unlock_behind);
	return py_use_unlock_behind;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_close_behind(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_close_behind;
	py_use_close_behind = PyInt_FromLong(object->use_close_behind);
	return py_use_close_behind;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_buf_named_pipes(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_buf_named_pipes;
	py_buf_named_pipes = PyInt_FromLong(object->buf_named_pipes);
	return py_buf_named_pipes;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_lock_read_unlock(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_lock_read_unlock;
	py_use_lock_read_unlock = PyInt_FromLong(object->use_lock_read_unlock);
	return py_use_lock_read_unlock;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_utilize_nt_caching(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_utilize_nt_caching;
	py_utilize_nt_caching = PyInt_FromLong(object->utilize_nt_caching);
	return py_utilize_nt_caching;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_raw_read(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_raw_read;
	py_use_raw_read = PyInt_FromLong(object->use_raw_read);
	return py_use_raw_read;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_raw_write(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_raw_write;
	py_use_raw_write = PyInt_FromLong(object->use_raw_write);
	return py_use_raw_write;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_write_raw_data(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_write_raw_data;
	py_use_write_raw_data = PyInt_FromLong(object->use_write_raw_data);
	return py_use_write_raw_data;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_encryption(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_encryption;
	py_use_encryption = PyInt_FromLong(object->use_encryption);
	return py_use_encryption;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_buf_files_deny_write(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_buf_files_deny_write;
	py_buf_files_deny_write = PyInt_FromLong(object->buf_files_deny_write);
	return py_buf_files_deny_write;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_buf_read_only_files(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_buf_read_only_files;
	py_buf_read_only_files = PyInt_FromLong(object->buf_read_only_files);
	return py_buf_read_only_files;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_force_core_create_mode(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_force_core_create_mode;
	py_force_core_create_mode = PyInt_FromLong(object->force_core_create_mode);
	return py_force_core_create_mode;
}

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

static PyObject *py_wkssvc_NetWkstaInfo502_get_use_512_byte_max_transfer(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo502 *object = (struct wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(obj);
	PyObject *py_use_512_byte_max_transfer;
	py_use_512_byte_max_transfer = PyInt_FromLong(object->use_512_byte_max_transfer);
	return py_use_512_byte_max_transfer;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo502_getsetters[] = {
	{ discard_const_p(char, "char_wait"), py_wkssvc_NetWkstaInfo502_get_char_wait, py_wkssvc_NetWkstaInfo502_set_char_wait },
	{ discard_const_p(char, "collection_time"), py_wkssvc_NetWkstaInfo502_get_collection_time, py_wkssvc_NetWkstaInfo502_set_collection_time },
	{ discard_const_p(char, "maximum_collection_count"), py_wkssvc_NetWkstaInfo502_get_maximum_collection_count, py_wkssvc_NetWkstaInfo502_set_maximum_collection_count },
	{ discard_const_p(char, "keep_connection"), py_wkssvc_NetWkstaInfo502_get_keep_connection, py_wkssvc_NetWkstaInfo502_set_keep_connection },
	{ discard_const_p(char, "max_commands"), py_wkssvc_NetWkstaInfo502_get_max_commands, py_wkssvc_NetWkstaInfo502_set_max_commands },
	{ discard_const_p(char, "session_timeout"), py_wkssvc_NetWkstaInfo502_get_session_timeout, py_wkssvc_NetWkstaInfo502_set_session_timeout },
	{ discard_const_p(char, "size_char_buf"), py_wkssvc_NetWkstaInfo502_get_size_char_buf, py_wkssvc_NetWkstaInfo502_set_size_char_buf },
	{ discard_const_p(char, "max_threads"), py_wkssvc_NetWkstaInfo502_get_max_threads, py_wkssvc_NetWkstaInfo502_set_max_threads },
	{ discard_const_p(char, "lock_quota"), py_wkssvc_NetWkstaInfo502_get_lock_quota, py_wkssvc_NetWkstaInfo502_set_lock_quota },
	{ discard_const_p(char, "lock_increment"), py_wkssvc_NetWkstaInfo502_get_lock_increment, py_wkssvc_NetWkstaInfo502_set_lock_increment },
	{ discard_const_p(char, "lock_maximum"), py_wkssvc_NetWkstaInfo502_get_lock_maximum, py_wkssvc_NetWkstaInfo502_set_lock_maximum },
	{ discard_const_p(char, "pipe_increment"), py_wkssvc_NetWkstaInfo502_get_pipe_increment, py_wkssvc_NetWkstaInfo502_set_pipe_increment },
	{ discard_const_p(char, "pipe_maximum"), py_wkssvc_NetWkstaInfo502_get_pipe_maximum, py_wkssvc_NetWkstaInfo502_set_pipe_maximum },
	{ discard_const_p(char, "cache_file_timeout"), py_wkssvc_NetWkstaInfo502_get_cache_file_timeout, py_wkssvc_NetWkstaInfo502_set_cache_file_timeout },
	{ discard_const_p(char, "dormant_file_limit"), py_wkssvc_NetWkstaInfo502_get_dormant_file_limit, py_wkssvc_NetWkstaInfo502_set_dormant_file_limit },
	{ discard_const_p(char, "read_ahead_throughput"), py_wkssvc_NetWkstaInfo502_get_read_ahead_throughput, py_wkssvc_NetWkstaInfo502_set_read_ahead_throughput },
	{ discard_const_p(char, "num_mailslot_buffers"), py_wkssvc_NetWkstaInfo502_get_num_mailslot_buffers, py_wkssvc_NetWkstaInfo502_set_num_mailslot_buffers },
	{ discard_const_p(char, "num_srv_announce_buffers"), py_wkssvc_NetWkstaInfo502_get_num_srv_announce_buffers, py_wkssvc_NetWkstaInfo502_set_num_srv_announce_buffers },
	{ discard_const_p(char, "max_illegal_dgram_events"), py_wkssvc_NetWkstaInfo502_get_max_illegal_dgram_events, py_wkssvc_NetWkstaInfo502_set_max_illegal_dgram_events },
	{ discard_const_p(char, "dgram_event_reset_freq"), py_wkssvc_NetWkstaInfo502_get_dgram_event_reset_freq, py_wkssvc_NetWkstaInfo502_set_dgram_event_reset_freq },
	{ discard_const_p(char, "log_election_packets"), py_wkssvc_NetWkstaInfo502_get_log_election_packets, py_wkssvc_NetWkstaInfo502_set_log_election_packets },
	{ discard_const_p(char, "use_opportunistic_locking"), py_wkssvc_NetWkstaInfo502_get_use_opportunistic_locking, py_wkssvc_NetWkstaInfo502_set_use_opportunistic_locking },
	{ discard_const_p(char, "use_unlock_behind"), py_wkssvc_NetWkstaInfo502_get_use_unlock_behind, py_wkssvc_NetWkstaInfo502_set_use_unlock_behind },
	{ discard_const_p(char, "use_close_behind"), py_wkssvc_NetWkstaInfo502_get_use_close_behind, py_wkssvc_NetWkstaInfo502_set_use_close_behind },
	{ discard_const_p(char, "buf_named_pipes"), py_wkssvc_NetWkstaInfo502_get_buf_named_pipes, py_wkssvc_NetWkstaInfo502_set_buf_named_pipes },
	{ discard_const_p(char, "use_lock_read_unlock"), py_wkssvc_NetWkstaInfo502_get_use_lock_read_unlock, py_wkssvc_NetWkstaInfo502_set_use_lock_read_unlock },
	{ discard_const_p(char, "utilize_nt_caching"), py_wkssvc_NetWkstaInfo502_get_utilize_nt_caching, py_wkssvc_NetWkstaInfo502_set_utilize_nt_caching },
	{ discard_const_p(char, "use_raw_read"), py_wkssvc_NetWkstaInfo502_get_use_raw_read, py_wkssvc_NetWkstaInfo502_set_use_raw_read },
	{ discard_const_p(char, "use_raw_write"), py_wkssvc_NetWkstaInfo502_get_use_raw_write, py_wkssvc_NetWkstaInfo502_set_use_raw_write },
	{ discard_const_p(char, "use_write_raw_data"), py_wkssvc_NetWkstaInfo502_get_use_write_raw_data, py_wkssvc_NetWkstaInfo502_set_use_write_raw_data },
	{ discard_const_p(char, "use_encryption"), py_wkssvc_NetWkstaInfo502_get_use_encryption, py_wkssvc_NetWkstaInfo502_set_use_encryption },
	{ discard_const_p(char, "buf_files_deny_write"), py_wkssvc_NetWkstaInfo502_get_buf_files_deny_write, py_wkssvc_NetWkstaInfo502_set_buf_files_deny_write },
	{ discard_const_p(char, "buf_read_only_files"), py_wkssvc_NetWkstaInfo502_get_buf_read_only_files, py_wkssvc_NetWkstaInfo502_set_buf_read_only_files },
	{ discard_const_p(char, "force_core_create_mode"), py_wkssvc_NetWkstaInfo502_get_force_core_create_mode, py_wkssvc_NetWkstaInfo502_set_force_core_create_mode },
	{ discard_const_p(char, "use_512_byte_max_transfer"), py_wkssvc_NetWkstaInfo502_get_use_512_byte_max_transfer, py_wkssvc_NetWkstaInfo502_set_use_512_byte_max_transfer },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo502_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo502",
	.tp_getset = py_wkssvc_NetWkstaInfo502_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo502_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1010_get_char_wait(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1010 *object = (struct wkssvc_NetWkstaInfo1010 *)pytalloc_get_ptr(obj);
	PyObject *py_char_wait;
	py_char_wait = PyInt_FromLong(object->char_wait);
	return py_char_wait;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1010_getsetters[] = {
	{ discard_const_p(char, "char_wait"), py_wkssvc_NetWkstaInfo1010_get_char_wait, py_wkssvc_NetWkstaInfo1010_set_char_wait },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1010_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1010",
	.tp_getset = py_wkssvc_NetWkstaInfo1010_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1010_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1011_get_collection_time(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1011 *object = (struct wkssvc_NetWkstaInfo1011 *)pytalloc_get_ptr(obj);
	PyObject *py_collection_time;
	py_collection_time = PyInt_FromLong(object->collection_time);
	return py_collection_time;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1011_getsetters[] = {
	{ discard_const_p(char, "collection_time"), py_wkssvc_NetWkstaInfo1011_get_collection_time, py_wkssvc_NetWkstaInfo1011_set_collection_time },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1011_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1011",
	.tp_getset = py_wkssvc_NetWkstaInfo1011_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1011_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1012_get_maximum_collection_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1012 *object = (struct wkssvc_NetWkstaInfo1012 *)pytalloc_get_ptr(obj);
	PyObject *py_maximum_collection_count;
	py_maximum_collection_count = PyInt_FromLong(object->maximum_collection_count);
	return py_maximum_collection_count;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1012_getsetters[] = {
	{ discard_const_p(char, "maximum_collection_count"), py_wkssvc_NetWkstaInfo1012_get_maximum_collection_count, py_wkssvc_NetWkstaInfo1012_set_maximum_collection_count },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1012_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1012",
	.tp_getset = py_wkssvc_NetWkstaInfo1012_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1012_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1013_get_keep_connection(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1013 *object = (struct wkssvc_NetWkstaInfo1013 *)pytalloc_get_ptr(obj);
	PyObject *py_keep_connection;
	py_keep_connection = PyInt_FromLong(object->keep_connection);
	return py_keep_connection;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1013_getsetters[] = {
	{ discard_const_p(char, "keep_connection"), py_wkssvc_NetWkstaInfo1013_get_keep_connection, py_wkssvc_NetWkstaInfo1013_set_keep_connection },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1013_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1013",
	.tp_getset = py_wkssvc_NetWkstaInfo1013_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1013_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1018_get_session_timeout(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1018 *object = (struct wkssvc_NetWkstaInfo1018 *)pytalloc_get_ptr(obj);
	PyObject *py_session_timeout;
	py_session_timeout = PyInt_FromLong(object->session_timeout);
	return py_session_timeout;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1018_getsetters[] = {
	{ discard_const_p(char, "session_timeout"), py_wkssvc_NetWkstaInfo1018_get_session_timeout, py_wkssvc_NetWkstaInfo1018_set_session_timeout },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1018_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1018",
	.tp_getset = py_wkssvc_NetWkstaInfo1018_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1018_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1023_get_size_char_buf(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1023 *object = (struct wkssvc_NetWkstaInfo1023 *)pytalloc_get_ptr(obj);
	PyObject *py_size_char_buf;
	py_size_char_buf = PyInt_FromLong(object->size_char_buf);
	return py_size_char_buf;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1023_getsetters[] = {
	{ discard_const_p(char, "size_char_buf"), py_wkssvc_NetWkstaInfo1023_get_size_char_buf, py_wkssvc_NetWkstaInfo1023_set_size_char_buf },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1023_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1023",
	.tp_getset = py_wkssvc_NetWkstaInfo1023_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1023_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1027_get_errorlog_sz(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1027 *object = (struct wkssvc_NetWkstaInfo1027 *)pytalloc_get_ptr(obj);
	PyObject *py_errorlog_sz;
	py_errorlog_sz = PyInt_FromLong(object->errorlog_sz);
	return py_errorlog_sz;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1027_getsetters[] = {
	{ discard_const_p(char, "errorlog_sz"), py_wkssvc_NetWkstaInfo1027_get_errorlog_sz, py_wkssvc_NetWkstaInfo1027_set_errorlog_sz },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1027_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1027",
	.tp_getset = py_wkssvc_NetWkstaInfo1027_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1027_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1028_get_print_buf_time(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1028 *object = (struct wkssvc_NetWkstaInfo1028 *)pytalloc_get_ptr(obj);
	PyObject *py_print_buf_time;
	py_print_buf_time = PyInt_FromLong(object->print_buf_time);
	return py_print_buf_time;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1028_getsetters[] = {
	{ discard_const_p(char, "print_buf_time"), py_wkssvc_NetWkstaInfo1028_get_print_buf_time, py_wkssvc_NetWkstaInfo1028_set_print_buf_time },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1028_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1028",
	.tp_getset = py_wkssvc_NetWkstaInfo1028_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1028_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1032_get_wrk_heuristics(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1032 *object = (struct wkssvc_NetWkstaInfo1032 *)pytalloc_get_ptr(obj);
	PyObject *py_wrk_heuristics;
	py_wrk_heuristics = PyInt_FromLong(object->wrk_heuristics);
	return py_wrk_heuristics;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1032_getsetters[] = {
	{ discard_const_p(char, "wrk_heuristics"), py_wkssvc_NetWkstaInfo1032_get_wrk_heuristics, py_wkssvc_NetWkstaInfo1032_set_wrk_heuristics },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1032_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1032",
	.tp_getset = py_wkssvc_NetWkstaInfo1032_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1032_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1033_get_max_threads(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1033 *object = (struct wkssvc_NetWkstaInfo1033 *)pytalloc_get_ptr(obj);
	PyObject *py_max_threads;
	py_max_threads = PyInt_FromLong(object->max_threads);
	return py_max_threads;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1033_getsetters[] = {
	{ discard_const_p(char, "max_threads"), py_wkssvc_NetWkstaInfo1033_get_max_threads, py_wkssvc_NetWkstaInfo1033_set_max_threads },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1033_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1033",
	.tp_getset = py_wkssvc_NetWkstaInfo1033_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1033_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1041_get_lock_quota(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1041 *object = (struct wkssvc_NetWkstaInfo1041 *)pytalloc_get_ptr(obj);
	PyObject *py_lock_quota;
	py_lock_quota = PyInt_FromLong(object->lock_quota);
	return py_lock_quota;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1041_getsetters[] = {
	{ discard_const_p(char, "lock_quota"), py_wkssvc_NetWkstaInfo1041_get_lock_quota, py_wkssvc_NetWkstaInfo1041_set_lock_quota },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1041_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1041",
	.tp_getset = py_wkssvc_NetWkstaInfo1041_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1041_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1042_get_lock_increment(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1042 *object = (struct wkssvc_NetWkstaInfo1042 *)pytalloc_get_ptr(obj);
	PyObject *py_lock_increment;
	py_lock_increment = PyInt_FromLong(object->lock_increment);
	return py_lock_increment;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1042_getsetters[] = {
	{ discard_const_p(char, "lock_increment"), py_wkssvc_NetWkstaInfo1042_get_lock_increment, py_wkssvc_NetWkstaInfo1042_set_lock_increment },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1042_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1042",
	.tp_getset = py_wkssvc_NetWkstaInfo1042_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1042_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1043_get_lock_maximum(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1043 *object = (struct wkssvc_NetWkstaInfo1043 *)pytalloc_get_ptr(obj);
	PyObject *py_lock_maximum;
	py_lock_maximum = PyInt_FromLong(object->lock_maximum);
	return py_lock_maximum;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1043_getsetters[] = {
	{ discard_const_p(char, "lock_maximum"), py_wkssvc_NetWkstaInfo1043_get_lock_maximum, py_wkssvc_NetWkstaInfo1043_set_lock_maximum },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1043_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1043",
	.tp_getset = py_wkssvc_NetWkstaInfo1043_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1043_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1044_get_pipe_increment(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1044 *object = (struct wkssvc_NetWkstaInfo1044 *)pytalloc_get_ptr(obj);
	PyObject *py_pipe_increment;
	py_pipe_increment = PyInt_FromLong(object->pipe_increment);
	return py_pipe_increment;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1044_getsetters[] = {
	{ discard_const_p(char, "pipe_increment"), py_wkssvc_NetWkstaInfo1044_get_pipe_increment, py_wkssvc_NetWkstaInfo1044_set_pipe_increment },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1044_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1044",
	.tp_getset = py_wkssvc_NetWkstaInfo1044_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1044_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1045_get_pipe_maximum(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1045 *object = (struct wkssvc_NetWkstaInfo1045 *)pytalloc_get_ptr(obj);
	PyObject *py_pipe_maximum;
	py_pipe_maximum = PyInt_FromLong(object->pipe_maximum);
	return py_pipe_maximum;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1045_getsetters[] = {
	{ discard_const_p(char, "pipe_maximum"), py_wkssvc_NetWkstaInfo1045_get_pipe_maximum, py_wkssvc_NetWkstaInfo1045_set_pipe_maximum },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1045_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1045",
	.tp_getset = py_wkssvc_NetWkstaInfo1045_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1045_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1046_get_dormant_file_limit(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1046 *object = (struct wkssvc_NetWkstaInfo1046 *)pytalloc_get_ptr(obj);
	PyObject *py_dormant_file_limit;
	py_dormant_file_limit = PyInt_FromLong(object->dormant_file_limit);
	return py_dormant_file_limit;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1046_getsetters[] = {
	{ discard_const_p(char, "dormant_file_limit"), py_wkssvc_NetWkstaInfo1046_get_dormant_file_limit, py_wkssvc_NetWkstaInfo1046_set_dormant_file_limit },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1046_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1046",
	.tp_getset = py_wkssvc_NetWkstaInfo1046_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1046_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1047_get_cache_file_timeout(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1047 *object = (struct wkssvc_NetWkstaInfo1047 *)pytalloc_get_ptr(obj);
	PyObject *py_cache_file_timeout;
	py_cache_file_timeout = PyInt_FromLong(object->cache_file_timeout);
	return py_cache_file_timeout;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1047_getsetters[] = {
	{ discard_const_p(char, "cache_file_timeout"), py_wkssvc_NetWkstaInfo1047_get_cache_file_timeout, py_wkssvc_NetWkstaInfo1047_set_cache_file_timeout },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1047_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1047",
	.tp_getset = py_wkssvc_NetWkstaInfo1047_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1047_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1048_get_use_opportunistic_locking(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1048 *object = (struct wkssvc_NetWkstaInfo1048 *)pytalloc_get_ptr(obj);
	PyObject *py_use_opportunistic_locking;
	py_use_opportunistic_locking = PyInt_FromLong(object->use_opportunistic_locking);
	return py_use_opportunistic_locking;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1048_getsetters[] = {
	{ discard_const_p(char, "use_opportunistic_locking"), py_wkssvc_NetWkstaInfo1048_get_use_opportunistic_locking, py_wkssvc_NetWkstaInfo1048_set_use_opportunistic_locking },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1048_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1048",
	.tp_getset = py_wkssvc_NetWkstaInfo1048_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1048_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1049_get_use_unlock_behind(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1049 *object = (struct wkssvc_NetWkstaInfo1049 *)pytalloc_get_ptr(obj);
	PyObject *py_use_unlock_behind;
	py_use_unlock_behind = PyInt_FromLong(object->use_unlock_behind);
	return py_use_unlock_behind;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1049_getsetters[] = {
	{ discard_const_p(char, "use_unlock_behind"), py_wkssvc_NetWkstaInfo1049_get_use_unlock_behind, py_wkssvc_NetWkstaInfo1049_set_use_unlock_behind },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1049_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1049",
	.tp_getset = py_wkssvc_NetWkstaInfo1049_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1049_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1050_get_use_close_behind(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1050 *object = (struct wkssvc_NetWkstaInfo1050 *)pytalloc_get_ptr(obj);
	PyObject *py_use_close_behind;
	py_use_close_behind = PyInt_FromLong(object->use_close_behind);
	return py_use_close_behind;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1050_getsetters[] = {
	{ discard_const_p(char, "use_close_behind"), py_wkssvc_NetWkstaInfo1050_get_use_close_behind, py_wkssvc_NetWkstaInfo1050_set_use_close_behind },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1050_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1050",
	.tp_getset = py_wkssvc_NetWkstaInfo1050_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1050_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1051_get_buf_named_pipes(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1051 *object = (struct wkssvc_NetWkstaInfo1051 *)pytalloc_get_ptr(obj);
	PyObject *py_buf_named_pipes;
	py_buf_named_pipes = PyInt_FromLong(object->buf_named_pipes);
	return py_buf_named_pipes;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1051_getsetters[] = {
	{ discard_const_p(char, "buf_named_pipes"), py_wkssvc_NetWkstaInfo1051_get_buf_named_pipes, py_wkssvc_NetWkstaInfo1051_set_buf_named_pipes },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1051_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1051",
	.tp_getset = py_wkssvc_NetWkstaInfo1051_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1051_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1052_get_use_lock_read_unlock(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1052 *object = (struct wkssvc_NetWkstaInfo1052 *)pytalloc_get_ptr(obj);
	PyObject *py_use_lock_read_unlock;
	py_use_lock_read_unlock = PyInt_FromLong(object->use_lock_read_unlock);
	return py_use_lock_read_unlock;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1052_getsetters[] = {
	{ discard_const_p(char, "use_lock_read_unlock"), py_wkssvc_NetWkstaInfo1052_get_use_lock_read_unlock, py_wkssvc_NetWkstaInfo1052_set_use_lock_read_unlock },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1052_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1052",
	.tp_getset = py_wkssvc_NetWkstaInfo1052_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1052_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1053_get_utilize_nt_caching(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1053 *object = (struct wkssvc_NetWkstaInfo1053 *)pytalloc_get_ptr(obj);
	PyObject *py_utilize_nt_caching;
	py_utilize_nt_caching = PyInt_FromLong(object->utilize_nt_caching);
	return py_utilize_nt_caching;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1053_getsetters[] = {
	{ discard_const_p(char, "utilize_nt_caching"), py_wkssvc_NetWkstaInfo1053_get_utilize_nt_caching, py_wkssvc_NetWkstaInfo1053_set_utilize_nt_caching },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1053_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1053",
	.tp_getset = py_wkssvc_NetWkstaInfo1053_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1053_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1054_get_use_raw_read(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1054 *object = (struct wkssvc_NetWkstaInfo1054 *)pytalloc_get_ptr(obj);
	PyObject *py_use_raw_read;
	py_use_raw_read = PyInt_FromLong(object->use_raw_read);
	return py_use_raw_read;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1054_getsetters[] = {
	{ discard_const_p(char, "use_raw_read"), py_wkssvc_NetWkstaInfo1054_get_use_raw_read, py_wkssvc_NetWkstaInfo1054_set_use_raw_read },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1054_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1054",
	.tp_getset = py_wkssvc_NetWkstaInfo1054_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1054_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1055_get_use_raw_write(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1055 *object = (struct wkssvc_NetWkstaInfo1055 *)pytalloc_get_ptr(obj);
	PyObject *py_use_raw_write;
	py_use_raw_write = PyInt_FromLong(object->use_raw_write);
	return py_use_raw_write;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1055_getsetters[] = {
	{ discard_const_p(char, "use_raw_write"), py_wkssvc_NetWkstaInfo1055_get_use_raw_write, py_wkssvc_NetWkstaInfo1055_set_use_raw_write },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1055_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1055",
	.tp_getset = py_wkssvc_NetWkstaInfo1055_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1055_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1056_get_use_write_raw_data(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1056 *object = (struct wkssvc_NetWkstaInfo1056 *)pytalloc_get_ptr(obj);
	PyObject *py_use_write_raw_data;
	py_use_write_raw_data = PyInt_FromLong(object->use_write_raw_data);
	return py_use_write_raw_data;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1056_getsetters[] = {
	{ discard_const_p(char, "use_write_raw_data"), py_wkssvc_NetWkstaInfo1056_get_use_write_raw_data, py_wkssvc_NetWkstaInfo1056_set_use_write_raw_data },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1056_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1056",
	.tp_getset = py_wkssvc_NetWkstaInfo1056_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1056_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1057_get_use_encryption(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1057 *object = (struct wkssvc_NetWkstaInfo1057 *)pytalloc_get_ptr(obj);
	PyObject *py_use_encryption;
	py_use_encryption = PyInt_FromLong(object->use_encryption);
	return py_use_encryption;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1057_getsetters[] = {
	{ discard_const_p(char, "use_encryption"), py_wkssvc_NetWkstaInfo1057_get_use_encryption, py_wkssvc_NetWkstaInfo1057_set_use_encryption },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1057_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1057",
	.tp_getset = py_wkssvc_NetWkstaInfo1057_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1057_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1058_get_buf_files_deny_write(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1058 *object = (struct wkssvc_NetWkstaInfo1058 *)pytalloc_get_ptr(obj);
	PyObject *py_buf_files_deny_write;
	py_buf_files_deny_write = PyInt_FromLong(object->buf_files_deny_write);
	return py_buf_files_deny_write;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1058_getsetters[] = {
	{ discard_const_p(char, "buf_files_deny_write"), py_wkssvc_NetWkstaInfo1058_get_buf_files_deny_write, py_wkssvc_NetWkstaInfo1058_set_buf_files_deny_write },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1058_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1058",
	.tp_getset = py_wkssvc_NetWkstaInfo1058_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1058_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1059_get_buf_read_only_files(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1059 *object = (struct wkssvc_NetWkstaInfo1059 *)pytalloc_get_ptr(obj);
	PyObject *py_buf_read_only_files;
	py_buf_read_only_files = PyInt_FromLong(object->buf_read_only_files);
	return py_buf_read_only_files;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1059_getsetters[] = {
	{ discard_const_p(char, "buf_read_only_files"), py_wkssvc_NetWkstaInfo1059_get_buf_read_only_files, py_wkssvc_NetWkstaInfo1059_set_buf_read_only_files },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1059_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1059",
	.tp_getset = py_wkssvc_NetWkstaInfo1059_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1059_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1060_get_force_core_create_mode(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1060 *object = (struct wkssvc_NetWkstaInfo1060 *)pytalloc_get_ptr(obj);
	PyObject *py_force_core_create_mode;
	py_force_core_create_mode = PyInt_FromLong(object->force_core_create_mode);
	return py_force_core_create_mode;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1060_getsetters[] = {
	{ discard_const_p(char, "force_core_create_mode"), py_wkssvc_NetWkstaInfo1060_get_force_core_create_mode, py_wkssvc_NetWkstaInfo1060_set_force_core_create_mode },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1060_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1060",
	.tp_getset = py_wkssvc_NetWkstaInfo1060_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1060_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1061_get_use_512_byte_max_transfer(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1061 *object = (struct wkssvc_NetWkstaInfo1061 *)pytalloc_get_ptr(obj);
	PyObject *py_use_512_byte_max_transfer;
	py_use_512_byte_max_transfer = PyInt_FromLong(object->use_512_byte_max_transfer);
	return py_use_512_byte_max_transfer;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1061_getsetters[] = {
	{ discard_const_p(char, "use_512_byte_max_transfer"), py_wkssvc_NetWkstaInfo1061_get_use_512_byte_max_transfer, py_wkssvc_NetWkstaInfo1061_set_use_512_byte_max_transfer },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1061_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1061",
	.tp_getset = py_wkssvc_NetWkstaInfo1061_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1061_new,
};


static PyObject *py_wkssvc_NetWkstaInfo1062_get_read_ahead_throughput(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaInfo1062 *object = (struct wkssvc_NetWkstaInfo1062 *)pytalloc_get_ptr(obj);
	PyObject *py_read_ahead_throughput;
	py_read_ahead_throughput = PyInt_FromLong(object->read_ahead_throughput);
	return py_read_ahead_throughput;
}

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

static PyGetSetDef py_wkssvc_NetWkstaInfo1062_getsetters[] = {
	{ discard_const_p(char, "read_ahead_throughput"), py_wkssvc_NetWkstaInfo1062_get_read_ahead_throughput, py_wkssvc_NetWkstaInfo1062_set_read_ahead_throughput },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaInfo1062_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaInfo1062",
	.tp_getset = py_wkssvc_NetWkstaInfo1062_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaInfo1062_new,
};

PyObject *py_import_wkssvc_NetWkstaInfo(TALLOC_CTX *mem_ctx, int level, union wkssvc_NetWkstaInfo *in)
{
	PyObject *ret;

	switch (level) {
		case 100:
			if (in->info100 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo100_Type, in->info100, in->info100);
			}
			return ret;

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

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

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

		case 1010:
			if (in->info1010 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1010_Type, in->info1010, in->info1010);
			}
			return ret;

		case 1011:
			if (in->info1011 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1011_Type, in->info1011, in->info1011);
			}
			return ret;

		case 1012:
			if (in->info1012 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1012_Type, in->info1012, in->info1012);
			}
			return ret;

		case 1013:
			if (in->info1013 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1013_Type, in->info1013, in->info1013);
			}
			return ret;

		case 1018:
			if (in->info1018 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1018_Type, in->info1018, in->info1018);
			}
			return ret;

		case 1023:
			if (in->info1023 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1023_Type, in->info1023, in->info1023);
			}
			return ret;

		case 1027:
			if (in->info1027 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1027_Type, in->info1027, in->info1027);
			}
			return ret;

		case 1028:
			if (in->info1028 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1028_Type, in->info1028, in->info1028);
			}
			return ret;

		case 1032:
			if (in->info1032 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1032_Type, in->info1032, in->info1032);
			}
			return ret;

		case 1033:
			if (in->info1033 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1033_Type, in->info1033, in->info1033);
			}
			return ret;

		case 1041:
			if (in->info1041 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1041_Type, in->info1041, in->info1041);
			}
			return ret;

		case 1042:
			if (in->info1042 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1042_Type, in->info1042, in->info1042);
			}
			return ret;

		case 1043:
			if (in->info1043 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1043_Type, in->info1043, in->info1043);
			}
			return ret;

		case 1044:
			if (in->info1044 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1044_Type, in->info1044, in->info1044);
			}
			return ret;

		case 1045:
			if (in->info1045 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1045_Type, in->info1045, in->info1045);
			}
			return ret;

		case 1046:
			if (in->info1046 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1046_Type, in->info1046, in->info1046);
			}
			return ret;

		case 1047:
			if (in->info1047 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1047_Type, in->info1047, in->info1047);
			}
			return ret;

		case 1048:
			if (in->info1048 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1048_Type, in->info1048, in->info1048);
			}
			return ret;

		case 1049:
			if (in->info1049 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1049_Type, in->info1049, in->info1049);
			}
			return ret;

		case 1050:
			if (in->info1050 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1050_Type, in->info1050, in->info1050);
			}
			return ret;

		case 1051:
			if (in->info1051 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1051_Type, in->info1051, in->info1051);
			}
			return ret;

		case 1052:
			if (in->info1052 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1052_Type, in->info1052, in->info1052);
			}
			return ret;

		case 1053:
			if (in->info1053 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1053_Type, in->info1053, in->info1053);
			}
			return ret;

		case 1054:
			if (in->info1054 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1054_Type, in->info1054, in->info1054);
			}
			return ret;

		case 1055:
			if (in->info1055 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1055_Type, in->info1055, in->info1055);
			}
			return ret;

		case 1056:
			if (in->info1056 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1056_Type, in->info1056, in->info1056);
			}
			return ret;

		case 1057:
			if (in->info1057 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1057_Type, in->info1057, in->info1057);
			}
			return ret;

		case 1058:
			if (in->info1058 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1058_Type, in->info1058, in->info1058);
			}
			return ret;

		case 1059:
			if (in->info1059 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1059_Type, in->info1059, in->info1059);
			}
			return ret;

		case 1060:
			if (in->info1060 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1060_Type, in->info1060, in->info1060);
			}
			return ret;

		case 1061:
			if (in->info1061 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1061_Type, in->info1061, in->info1061);
			}
			return ret;

		case 1062:
			if (in->info1062 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetWkstaInfo1062_Type, in->info1062, in->info1062);
			}
			return ret;

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

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

union wkssvc_NetWkstaInfo *py_export_wkssvc_NetWkstaInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union wkssvc_NetWkstaInfo *ret = talloc_zero(mem_ctx, union wkssvc_NetWkstaInfo);
	switch (level) {
		case 100:
			if (in == Py_None) {
				ret->info100 = NULL;
			} else {
				ret->info100 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo100_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 wkssvc_NetWkstaInfo100 *)pytalloc_get_ptr(in);
			}
			break;

		case 101:
			if (in == Py_None) {
				ret->info101 = NULL;
			} else {
				ret->info101 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo101_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 wkssvc_NetWkstaInfo101 *)pytalloc_get_ptr(in);
			}
			break;

		case 102:
			if (in == Py_None) {
				ret->info102 = NULL;
			} else {
				ret->info102 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo102_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 wkssvc_NetWkstaInfo102 *)pytalloc_get_ptr(in);
			}
			break;

		case 502:
			if (in == Py_None) {
				ret->info502 = NULL;
			} else {
				ret->info502 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo502_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 wkssvc_NetWkstaInfo502 *)pytalloc_get_ptr(in);
			}
			break;

		case 1010:
			if (in == Py_None) {
				ret->info1010 = NULL;
			} else {
				ret->info1010 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1010_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 wkssvc_NetWkstaInfo1010 *)pytalloc_get_ptr(in);
			}
			break;

		case 1011:
			if (in == Py_None) {
				ret->info1011 = NULL;
			} else {
				ret->info1011 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1011_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->info1011 = (struct wkssvc_NetWkstaInfo1011 *)pytalloc_get_ptr(in);
			}
			break;

		case 1012:
			if (in == Py_None) {
				ret->info1012 = NULL;
			} else {
				ret->info1012 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1012_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->info1012 = (struct wkssvc_NetWkstaInfo1012 *)pytalloc_get_ptr(in);
			}
			break;

		case 1013:
			if (in == Py_None) {
				ret->info1013 = NULL;
			} else {
				ret->info1013 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1013_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->info1013 = (struct wkssvc_NetWkstaInfo1013 *)pytalloc_get_ptr(in);
			}
			break;

		case 1018:
			if (in == Py_None) {
				ret->info1018 = NULL;
			} else {
				ret->info1018 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1018_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 wkssvc_NetWkstaInfo1018 *)pytalloc_get_ptr(in);
			}
			break;

		case 1023:
			if (in == Py_None) {
				ret->info1023 = NULL;
			} else {
				ret->info1023 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1023_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->info1023 = (struct wkssvc_NetWkstaInfo1023 *)pytalloc_get_ptr(in);
			}
			break;

		case 1027:
			if (in == Py_None) {
				ret->info1027 = NULL;
			} else {
				ret->info1027 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1027_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->info1027 = (struct wkssvc_NetWkstaInfo1027 *)pytalloc_get_ptr(in);
			}
			break;

		case 1028:
			if (in == Py_None) {
				ret->info1028 = NULL;
			} else {
				ret->info1028 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1028_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->info1028 = (struct wkssvc_NetWkstaInfo1028 *)pytalloc_get_ptr(in);
			}
			break;

		case 1032:
			if (in == Py_None) {
				ret->info1032 = NULL;
			} else {
				ret->info1032 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1032_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->info1032 = (struct wkssvc_NetWkstaInfo1032 *)pytalloc_get_ptr(in);
			}
			break;

		case 1033:
			if (in == Py_None) {
				ret->info1033 = NULL;
			} else {
				ret->info1033 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1033_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->info1033 = (struct wkssvc_NetWkstaInfo1033 *)pytalloc_get_ptr(in);
			}
			break;

		case 1041:
			if (in == Py_None) {
				ret->info1041 = NULL;
			} else {
				ret->info1041 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1041_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->info1041 = (struct wkssvc_NetWkstaInfo1041 *)pytalloc_get_ptr(in);
			}
			break;

		case 1042:
			if (in == Py_None) {
				ret->info1042 = NULL;
			} else {
				ret->info1042 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1042_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->info1042 = (struct wkssvc_NetWkstaInfo1042 *)pytalloc_get_ptr(in);
			}
			break;

		case 1043:
			if (in == Py_None) {
				ret->info1043 = NULL;
			} else {
				ret->info1043 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1043_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->info1043 = (struct wkssvc_NetWkstaInfo1043 *)pytalloc_get_ptr(in);
			}
			break;

		case 1044:
			if (in == Py_None) {
				ret->info1044 = NULL;
			} else {
				ret->info1044 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1044_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->info1044 = (struct wkssvc_NetWkstaInfo1044 *)pytalloc_get_ptr(in);
			}
			break;

		case 1045:
			if (in == Py_None) {
				ret->info1045 = NULL;
			} else {
				ret->info1045 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1045_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->info1045 = (struct wkssvc_NetWkstaInfo1045 *)pytalloc_get_ptr(in);
			}
			break;

		case 1046:
			if (in == Py_None) {
				ret->info1046 = NULL;
			} else {
				ret->info1046 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1046_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->info1046 = (struct wkssvc_NetWkstaInfo1046 *)pytalloc_get_ptr(in);
			}
			break;

		case 1047:
			if (in == Py_None) {
				ret->info1047 = NULL;
			} else {
				ret->info1047 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1047_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->info1047 = (struct wkssvc_NetWkstaInfo1047 *)pytalloc_get_ptr(in);
			}
			break;

		case 1048:
			if (in == Py_None) {
				ret->info1048 = NULL;
			} else {
				ret->info1048 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1048_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->info1048 = (struct wkssvc_NetWkstaInfo1048 *)pytalloc_get_ptr(in);
			}
			break;

		case 1049:
			if (in == Py_None) {
				ret->info1049 = NULL;
			} else {
				ret->info1049 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1049_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->info1049 = (struct wkssvc_NetWkstaInfo1049 *)pytalloc_get_ptr(in);
			}
			break;

		case 1050:
			if (in == Py_None) {
				ret->info1050 = NULL;
			} else {
				ret->info1050 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1050_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->info1050 = (struct wkssvc_NetWkstaInfo1050 *)pytalloc_get_ptr(in);
			}
			break;

		case 1051:
			if (in == Py_None) {
				ret->info1051 = NULL;
			} else {
				ret->info1051 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1051_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->info1051 = (struct wkssvc_NetWkstaInfo1051 *)pytalloc_get_ptr(in);
			}
			break;

		case 1052:
			if (in == Py_None) {
				ret->info1052 = NULL;
			} else {
				ret->info1052 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1052_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->info1052 = (struct wkssvc_NetWkstaInfo1052 *)pytalloc_get_ptr(in);
			}
			break;

		case 1053:
			if (in == Py_None) {
				ret->info1053 = NULL;
			} else {
				ret->info1053 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1053_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->info1053 = (struct wkssvc_NetWkstaInfo1053 *)pytalloc_get_ptr(in);
			}
			break;

		case 1054:
			if (in == Py_None) {
				ret->info1054 = NULL;
			} else {
				ret->info1054 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1054_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->info1054 = (struct wkssvc_NetWkstaInfo1054 *)pytalloc_get_ptr(in);
			}
			break;

		case 1055:
			if (in == Py_None) {
				ret->info1055 = NULL;
			} else {
				ret->info1055 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1055_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->info1055 = (struct wkssvc_NetWkstaInfo1055 *)pytalloc_get_ptr(in);
			}
			break;

		case 1056:
			if (in == Py_None) {
				ret->info1056 = NULL;
			} else {
				ret->info1056 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1056_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->info1056 = (struct wkssvc_NetWkstaInfo1056 *)pytalloc_get_ptr(in);
			}
			break;

		case 1057:
			if (in == Py_None) {
				ret->info1057 = NULL;
			} else {
				ret->info1057 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1057_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->info1057 = (struct wkssvc_NetWkstaInfo1057 *)pytalloc_get_ptr(in);
			}
			break;

		case 1058:
			if (in == Py_None) {
				ret->info1058 = NULL;
			} else {
				ret->info1058 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1058_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->info1058 = (struct wkssvc_NetWkstaInfo1058 *)pytalloc_get_ptr(in);
			}
			break;

		case 1059:
			if (in == Py_None) {
				ret->info1059 = NULL;
			} else {
				ret->info1059 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1059_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->info1059 = (struct wkssvc_NetWkstaInfo1059 *)pytalloc_get_ptr(in);
			}
			break;

		case 1060:
			if (in == Py_None) {
				ret->info1060 = NULL;
			} else {
				ret->info1060 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1060_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->info1060 = (struct wkssvc_NetWkstaInfo1060 *)pytalloc_get_ptr(in);
			}
			break;

		case 1061:
			if (in == Py_None) {
				ret->info1061 = NULL;
			} else {
				ret->info1061 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1061_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->info1061 = (struct wkssvc_NetWkstaInfo1061 *)pytalloc_get_ptr(in);
			}
			break;

		case 1062:
			if (in == Py_None) {
				ret->info1062 = NULL;
			} else {
				ret->info1062 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaInfo1062_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->info1062 = (struct wkssvc_NetWkstaInfo1062 *)pytalloc_get_ptr(in);
			}
			break;

		default:
			break;

	}

	return ret;
}


static PyObject *py_wkssvc_NetrWkstaUserInfo0_get_user_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo0 *object = (struct wkssvc_NetrWkstaUserInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_user_name;
	if (object->user_name == NULL) {
		py_user_name = Py_None;
		Py_INCREF(py_user_name);
	} else {
		if (object->user_name == NULL) {
			py_user_name = Py_None;
			Py_INCREF(py_user_name);
		} else {
			py_user_name = PyUnicode_Decode(object->user_name, strlen(object->user_name), "utf-8", "ignore");
		}
	}
	return py_user_name;
}

static int py_wkssvc_NetrWkstaUserInfo0_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo0 *object = (struct wkssvc_NetrWkstaUserInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user_name = NULL;
	} else {
		object->user_name = NULL;
		if (PyUnicode_Check(value)) {
			object->user_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user_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_wkssvc_NetrWkstaUserInfo0_getsetters[] = {
	{ discard_const_p(char, "user_name"), py_wkssvc_NetrWkstaUserInfo0_get_user_name, py_wkssvc_NetrWkstaUserInfo0_set_user_name },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrWkstaUserInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrWkstaUserInfo0",
	.tp_getset = py_wkssvc_NetrWkstaUserInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrWkstaUserInfo0_new,
};


static PyObject *py_wkssvc_NetWkstaEnumUsersCtr0_get_entries_read(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersCtr0 *object = (struct wkssvc_NetWkstaEnumUsersCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_entries_read;
	py_entries_read = PyInt_FromLong(object->entries_read);
	return py_entries_read;
}

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

static PyObject *py_wkssvc_NetWkstaEnumUsersCtr0_get_user0(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersCtr0 *object = (struct wkssvc_NetWkstaEnumUsersCtr0 *)pytalloc_get_ptr(obj);
	PyObject *py_user0;
	if (object->user0 == NULL) {
		py_user0 = Py_None;
		Py_INCREF(py_user0);
	} else {
		py_user0 = PyList_New(object->entries_read);
		if (py_user0 == NULL) {
			return NULL;
		}
		{
			int user0_cntr_1;
			for (user0_cntr_1 = 0; user0_cntr_1 < object->entries_read; user0_cntr_1++) {
				PyObject *py_user0_1;
				py_user0_1 = pytalloc_reference_ex(&wkssvc_NetrWkstaUserInfo0_Type, object->user0, &object->user0[user0_cntr_1]);
				PyList_SetItem(py_user0, user0_cntr_1, py_user0_1);
			}
		}
	}
	return py_user0;
}

static int py_wkssvc_NetWkstaEnumUsersCtr0_set_user0(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersCtr0 *object = (struct wkssvc_NetWkstaEnumUsersCtr0 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->user0);
	if (value == Py_None) {
		object->user0 = NULL;
	} else {
		object->user0 = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int user0_cntr_1;
			object->user0 = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->user0, PyList_GET_SIZE(value));
			if (!object->user0) { return -1;; }
			talloc_set_name_const(object->user0, "ARRAY: object->user0");
			for (user0_cntr_1 = 0; user0_cntr_1 < PyList_GET_SIZE(value); user0_cntr_1++) {
				PY_CHECK_TYPE(&wkssvc_NetrWkstaUserInfo0_Type, PyList_GET_ITEM(value, user0_cntr_1), return -1;);
				if (talloc_reference(object->user0, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, user0_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->user0[user0_cntr_1] = *(struct wkssvc_NetrWkstaUserInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, user0_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_NetWkstaEnumUsersCtr0_getsetters[] = {
	{ discard_const_p(char, "entries_read"), py_wkssvc_NetWkstaEnumUsersCtr0_get_entries_read, py_wkssvc_NetWkstaEnumUsersCtr0_set_entries_read },
	{ discard_const_p(char, "user0"), py_wkssvc_NetWkstaEnumUsersCtr0_get_user0, py_wkssvc_NetWkstaEnumUsersCtr0_set_user0 },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaEnumUsersCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaEnumUsersCtr0",
	.tp_getset = py_wkssvc_NetWkstaEnumUsersCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaEnumUsersCtr0_new,
};


static PyObject *py_wkssvc_NetrWkstaUserInfo1_get_user_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_user_name;
	if (object->user_name == NULL) {
		py_user_name = Py_None;
		Py_INCREF(py_user_name);
	} else {
		if (object->user_name == NULL) {
			py_user_name = Py_None;
			Py_INCREF(py_user_name);
		} else {
			py_user_name = PyUnicode_Decode(object->user_name, strlen(object->user_name), "utf-8", "ignore");
		}
	}
	return py_user_name;
}

static int py_wkssvc_NetrWkstaUserInfo1_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user_name = NULL;
	} else {
		object->user_name = NULL;
		if (PyUnicode_Check(value)) {
			object->user_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user_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_wkssvc_NetrWkstaUserInfo1_get_logon_domain(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_logon_domain;
	if (object->logon_domain == NULL) {
		py_logon_domain = Py_None;
		Py_INCREF(py_logon_domain);
	} else {
		if (object->logon_domain == NULL) {
			py_logon_domain = Py_None;
			Py_INCREF(py_logon_domain);
		} else {
			py_logon_domain = PyUnicode_Decode(object->logon_domain, strlen(object->logon_domain), "utf-8", "ignore");
		}
	}
	return py_logon_domain;
}

static int py_wkssvc_NetrWkstaUserInfo1_set_logon_domain(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->logon_domain = NULL;
	} else {
		object->logon_domain = NULL;
		if (PyUnicode_Check(value)) {
			object->logon_domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->logon_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_wkssvc_NetrWkstaUserInfo1_get_other_domains(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_other_domains;
	if (object->other_domains == NULL) {
		py_other_domains = Py_None;
		Py_INCREF(py_other_domains);
	} else {
		if (object->other_domains == NULL) {
			py_other_domains = Py_None;
			Py_INCREF(py_other_domains);
		} else {
			py_other_domains = PyUnicode_Decode(object->other_domains, strlen(object->other_domains), "utf-8", "ignore");
		}
	}
	return py_other_domains;
}

static int py_wkssvc_NetrWkstaUserInfo1_set_other_domains(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->other_domains = NULL;
	} else {
		object->other_domains = NULL;
		if (PyUnicode_Check(value)) {
			object->other_domains = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->other_domains = 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_wkssvc_NetrWkstaUserInfo1_get_logon_server(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1 *object = (struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_logon_server;
	if (object->logon_server == NULL) {
		py_logon_server = Py_None;
		Py_INCREF(py_logon_server);
	} else {
		if (object->logon_server == NULL) {
			py_logon_server = Py_None;
			Py_INCREF(py_logon_server);
		} else {
			py_logon_server = PyUnicode_Decode(object->logon_server, strlen(object->logon_server), "utf-8", "ignore");
		}
	}
	return py_logon_server;
}

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

static PyGetSetDef py_wkssvc_NetrWkstaUserInfo1_getsetters[] = {
	{ discard_const_p(char, "user_name"), py_wkssvc_NetrWkstaUserInfo1_get_user_name, py_wkssvc_NetrWkstaUserInfo1_set_user_name },
	{ discard_const_p(char, "logon_domain"), py_wkssvc_NetrWkstaUserInfo1_get_logon_domain, py_wkssvc_NetrWkstaUserInfo1_set_logon_domain },
	{ discard_const_p(char, "other_domains"), py_wkssvc_NetrWkstaUserInfo1_get_other_domains, py_wkssvc_NetrWkstaUserInfo1_set_other_domains },
	{ discard_const_p(char, "logon_server"), py_wkssvc_NetrWkstaUserInfo1_get_logon_server, py_wkssvc_NetrWkstaUserInfo1_set_logon_server },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrWkstaUserInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrWkstaUserInfo1",
	.tp_getset = py_wkssvc_NetrWkstaUserInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrWkstaUserInfo1_new,
};


static PyObject *py_wkssvc_NetWkstaEnumUsersCtr1_get_entries_read(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersCtr1 *object = (struct wkssvc_NetWkstaEnumUsersCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_entries_read;
	py_entries_read = PyInt_FromLong(object->entries_read);
	return py_entries_read;
}

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

static PyObject *py_wkssvc_NetWkstaEnumUsersCtr1_get_user1(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersCtr1 *object = (struct wkssvc_NetWkstaEnumUsersCtr1 *)pytalloc_get_ptr(obj);
	PyObject *py_user1;
	if (object->user1 == NULL) {
		py_user1 = Py_None;
		Py_INCREF(py_user1);
	} else {
		py_user1 = PyList_New(object->entries_read);
		if (py_user1 == NULL) {
			return NULL;
		}
		{
			int user1_cntr_1;
			for (user1_cntr_1 = 0; user1_cntr_1 < object->entries_read; user1_cntr_1++) {
				PyObject *py_user1_1;
				py_user1_1 = pytalloc_reference_ex(&wkssvc_NetrWkstaUserInfo1_Type, object->user1, &object->user1[user1_cntr_1]);
				PyList_SetItem(py_user1, user1_cntr_1, py_user1_1);
			}
		}
	}
	return py_user1;
}

static int py_wkssvc_NetWkstaEnumUsersCtr1_set_user1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersCtr1 *object = (struct wkssvc_NetWkstaEnumUsersCtr1 *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->user1);
	if (value == Py_None) {
		object->user1 = NULL;
	} else {
		object->user1 = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int user1_cntr_1;
			object->user1 = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->user1, PyList_GET_SIZE(value));
			if (!object->user1) { return -1;; }
			talloc_set_name_const(object->user1, "ARRAY: object->user1");
			for (user1_cntr_1 = 0; user1_cntr_1 < PyList_GET_SIZE(value); user1_cntr_1++) {
				PY_CHECK_TYPE(&wkssvc_NetrWkstaUserInfo1_Type, PyList_GET_ITEM(value, user1_cntr_1), return -1;);
				if (talloc_reference(object->user1, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, user1_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->user1[user1_cntr_1] = *(struct wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, user1_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_NetWkstaEnumUsersCtr1_getsetters[] = {
	{ discard_const_p(char, "entries_read"), py_wkssvc_NetWkstaEnumUsersCtr1_get_entries_read, py_wkssvc_NetWkstaEnumUsersCtr1_set_entries_read },
	{ discard_const_p(char, "user1"), py_wkssvc_NetWkstaEnumUsersCtr1_get_user1, py_wkssvc_NetWkstaEnumUsersCtr1_set_user1 },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaEnumUsersCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaEnumUsersCtr1",
	.tp_getset = py_wkssvc_NetWkstaEnumUsersCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaEnumUsersCtr1_new,
};

PyObject *py_import_wkssvc_NetWkstaEnumUsersCtr(TALLOC_CTX *mem_ctx, int level, union wkssvc_NetWkstaEnumUsersCtr *in)
{
	PyObject *ret;

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

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

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

union wkssvc_NetWkstaEnumUsersCtr *py_export_wkssvc_NetWkstaEnumUsersCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union wkssvc_NetWkstaEnumUsersCtr *ret = talloc_zero(mem_ctx, union wkssvc_NetWkstaEnumUsersCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->user0 = NULL;
			} else {
				ret->user0 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaEnumUsersCtr0_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->user0 = (struct wkssvc_NetWkstaEnumUsersCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->user1 = NULL;
			} else {
				ret->user1 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaEnumUsersCtr1_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->user1 = (struct wkssvc_NetWkstaEnumUsersCtr1 *)pytalloc_get_ptr(in);
			}
			break;

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

	return ret;
}


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

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

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

static int py_wkssvc_NetWkstaEnumUsersInfo_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaEnumUsersInfo *object = (struct wkssvc_NetWkstaEnumUsersInfo *)pytalloc_get_ptr(py_obj);
	{
		union wkssvc_NetWkstaEnumUsersCtr *ctr_switch_0;
		ctr_switch_0 = py_export_wkssvc_NetWkstaEnumUsersCtr(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_wkssvc_NetWkstaEnumUsersInfo_getsetters[] = {
	{ discard_const_p(char, "level"), py_wkssvc_NetWkstaEnumUsersInfo_get_level, py_wkssvc_NetWkstaEnumUsersInfo_set_level },
	{ discard_const_p(char, "ctr"), py_wkssvc_NetWkstaEnumUsersInfo_get_ctr, py_wkssvc_NetWkstaEnumUsersInfo_set_ctr },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaEnumUsersInfo_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaEnumUsersInfo",
	.tp_getset = py_wkssvc_NetWkstaEnumUsersInfo_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaEnumUsersInfo_new,
};


static PyObject *py_wkssvc_NetrWkstaUserInfo1101_get_other_domains(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWkstaUserInfo1101 *object = (struct wkssvc_NetrWkstaUserInfo1101 *)pytalloc_get_ptr(obj);
	PyObject *py_other_domains;
	if (object->other_domains == NULL) {
		py_other_domains = Py_None;
		Py_INCREF(py_other_domains);
	} else {
		if (object->other_domains == NULL) {
			py_other_domains = Py_None;
			Py_INCREF(py_other_domains);
		} else {
			py_other_domains = PyUnicode_Decode(object->other_domains, strlen(object->other_domains), "utf-8", "ignore");
		}
	}
	return py_other_domains;
}

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

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


static PyTypeObject wkssvc_NetrWkstaUserInfo1101_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrWkstaUserInfo1101",
	.tp_getset = py_wkssvc_NetrWkstaUserInfo1101_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrWkstaUserInfo1101_new,
};

PyObject *py_import_wkssvc_NetrWkstaUserInfo(TALLOC_CTX *mem_ctx, int level, union wkssvc_NetrWkstaUserInfo *in)
{
	PyObject *ret;

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

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

		case 1101:
			if (in->info1101 == NULL) {
				ret = Py_None;
				Py_INCREF(ret);
			} else {
				ret = pytalloc_reference_ex(&wkssvc_NetrWkstaUserInfo1101_Type, in->info1101, in->info1101);
			}
			return ret;

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

union wkssvc_NetrWkstaUserInfo *py_export_wkssvc_NetrWkstaUserInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union wkssvc_NetrWkstaUserInfo *ret = talloc_zero(mem_ctx, union wkssvc_NetrWkstaUserInfo);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->info0 = NULL;
			} else {
				ret->info0 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrWkstaUserInfo0_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 wkssvc_NetrWkstaUserInfo0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrWkstaUserInfo1_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 wkssvc_NetrWkstaUserInfo1 *)pytalloc_get_ptr(in);
			}
			break;

		case 1101:
			if (in == Py_None) {
				ret->info1101 = NULL;
			} else {
				ret->info1101 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrWkstaUserInfo1101_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->info1101 = (struct wkssvc_NetrWkstaUserInfo1101 *)pytalloc_get_ptr(in);
			}
			break;

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

	return ret;
}


static PyObject *py_wkssvc_NetWkstaTransportInfo0_get_quality_of_service(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_quality_of_service;
	py_quality_of_service = PyInt_FromLong(object->quality_of_service);
	return py_quality_of_service;
}

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

static PyObject *py_wkssvc_NetWkstaTransportInfo0_get_vc_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_vc_count;
	py_vc_count = PyInt_FromLong(object->vc_count);
	return py_vc_count;
}

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

static PyObject *py_wkssvc_NetWkstaTransportInfo0_get_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)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_wkssvc_NetWkstaTransportInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)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_wkssvc_NetWkstaTransportInfo0_get_address(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_address;
	if (object->address == NULL) {
		py_address = Py_None;
		Py_INCREF(py_address);
	} else {
		if (object->address == NULL) {
			py_address = Py_None;
			Py_INCREF(py_address);
		} else {
			py_address = PyUnicode_Decode(object->address, strlen(object->address), "utf-8", "ignore");
		}
	}
	return py_address;
}

static int py_wkssvc_NetWkstaTransportInfo0_set_address(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->address = NULL;
	} else {
		object->address = NULL;
		if (PyUnicode_Check(value)) {
			object->address = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->address = 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_wkssvc_NetWkstaTransportInfo0_get_wan_link(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo0 *object = (struct wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_wan_link;
	py_wan_link = PyInt_FromLong(object->wan_link);
	return py_wan_link;
}

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

static PyGetSetDef py_wkssvc_NetWkstaTransportInfo0_getsetters[] = {
	{ discard_const_p(char, "quality_of_service"), py_wkssvc_NetWkstaTransportInfo0_get_quality_of_service, py_wkssvc_NetWkstaTransportInfo0_set_quality_of_service },
	{ discard_const_p(char, "vc_count"), py_wkssvc_NetWkstaTransportInfo0_get_vc_count, py_wkssvc_NetWkstaTransportInfo0_set_vc_count },
	{ discard_const_p(char, "name"), py_wkssvc_NetWkstaTransportInfo0_get_name, py_wkssvc_NetWkstaTransportInfo0_set_name },
	{ discard_const_p(char, "address"), py_wkssvc_NetWkstaTransportInfo0_get_address, py_wkssvc_NetWkstaTransportInfo0_set_address },
	{ discard_const_p(char, "wan_link"), py_wkssvc_NetWkstaTransportInfo0_get_wan_link, py_wkssvc_NetWkstaTransportInfo0_set_wan_link },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaTransportInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaTransportInfo0",
	.tp_getset = py_wkssvc_NetWkstaTransportInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaTransportInfo0_new,
};


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

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

static PyObject *py_wkssvc_NetWkstaTransportCtr0_get_array(PyObject *obj, void *closure)
{
	struct wkssvc_NetWkstaTransportCtr0 *object = (struct wkssvc_NetWkstaTransportCtr0 *)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(&wkssvc_NetWkstaTransportInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_wkssvc_NetWkstaTransportCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaTransportCtr0 *object = (struct wkssvc_NetWkstaTransportCtr0 *)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(&wkssvc_NetWkstaTransportInfo0_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 wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_NetWkstaTransportCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_wkssvc_NetWkstaTransportCtr0_get_count, py_wkssvc_NetWkstaTransportCtr0_set_count },
	{ discard_const_p(char, "array"), py_wkssvc_NetWkstaTransportCtr0_get_array, py_wkssvc_NetWkstaTransportCtr0_set_array },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaTransportCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaTransportCtr0",
	.tp_getset = py_wkssvc_NetWkstaTransportCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaTransportCtr0_new,
};

PyObject *py_import_wkssvc_NetWkstaTransportCtr(TALLOC_CTX *mem_ctx, int level, union wkssvc_NetWkstaTransportCtr *in)
{
	PyObject *ret;

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

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

union wkssvc_NetWkstaTransportCtr *py_export_wkssvc_NetWkstaTransportCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union wkssvc_NetWkstaTransportCtr *ret = talloc_zero(mem_ctx, union wkssvc_NetWkstaTransportCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetWkstaTransportCtr0_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 wkssvc_NetWkstaTransportCtr0 *)pytalloc_get_ptr(in);
			}
			break;

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

	return ret;
}


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

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

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

static int py_wkssvc_NetWkstaTransportInfo_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetWkstaTransportInfo *object = (struct wkssvc_NetWkstaTransportInfo *)pytalloc_get_ptr(py_obj);
	{
		union wkssvc_NetWkstaTransportCtr *ctr_switch_0;
		ctr_switch_0 = py_export_wkssvc_NetWkstaTransportCtr(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_wkssvc_NetWkstaTransportInfo_getsetters[] = {
	{ discard_const_p(char, "level"), py_wkssvc_NetWkstaTransportInfo_get_level, py_wkssvc_NetWkstaTransportInfo_set_level },
	{ discard_const_p(char, "ctr"), py_wkssvc_NetWkstaTransportInfo_get_ctr, py_wkssvc_NetWkstaTransportInfo_set_ctr },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetWkstaTransportInfo_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetWkstaTransportInfo",
	.tp_getset = py_wkssvc_NetWkstaTransportInfo_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetWkstaTransportInfo_new,
};


static PyObject *py_wkssvc_NetrUseInfo3_get_unknown1(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo3 *object = (struct wkssvc_NetrUseInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown1;
	if (object->unknown1 == NULL) {
		py_unknown1 = Py_None;
		Py_INCREF(py_unknown1);
	} else {
		if (object->unknown1 == NULL) {
			py_unknown1 = Py_None;
			Py_INCREF(py_unknown1);
		} else {
			py_unknown1 = PyUnicode_Decode(object->unknown1, strlen(object->unknown1), "utf-8", "ignore");
		}
	}
	return py_unknown1;
}

static int py_wkssvc_NetrUseInfo3_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo3 *object = (struct wkssvc_NetrUseInfo3 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->unknown1 = NULL;
	} else {
		object->unknown1 = NULL;
		if (PyUnicode_Check(value)) {
			object->unknown1 = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->unknown1 = 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_wkssvc_NetrUseInfo3_get_unknown2(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo3 *object = (struct wkssvc_NetrUseInfo3 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown2;
	if (object->unknown2 == NULL) {
		py_unknown2 = Py_None;
		Py_INCREF(py_unknown2);
	} else {
		if (object->unknown2 == NULL) {
			py_unknown2 = Py_None;
			Py_INCREF(py_unknown2);
		} else {
			py_unknown2 = PyUnicode_Decode(object->unknown2, strlen(object->unknown2), "utf-8", "ignore");
		}
	}
	return py_unknown2;
}

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

static PyGetSetDef py_wkssvc_NetrUseInfo3_getsetters[] = {
	{ discard_const_p(char, "unknown1"), py_wkssvc_NetrUseInfo3_get_unknown1, py_wkssvc_NetrUseInfo3_set_unknown1 },
	{ discard_const_p(char, "unknown2"), py_wkssvc_NetrUseInfo3_get_unknown2, py_wkssvc_NetrUseInfo3_set_unknown2 },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseInfo3_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseInfo3",
	.tp_getset = py_wkssvc_NetrUseInfo3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseInfo3_new,
};


static PyObject *py_wkssvc_NetrUseInfo2_get_local(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_local;
	if (object->local == NULL) {
		py_local = Py_None;
		Py_INCREF(py_local);
	} else {
		if (object->local == NULL) {
			py_local = Py_None;
			Py_INCREF(py_local);
		} else {
			py_local = PyUnicode_Decode(object->local, strlen(object->local), "utf-8", "ignore");
		}
	}
	return py_local;
}

static int py_wkssvc_NetrUseInfo2_set_local(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->local = NULL;
	} else {
		object->local = NULL;
		if (PyUnicode_Check(value)) {
			object->local = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->local = 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_wkssvc_NetrUseInfo2_get_remote(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_remote;
	if (object->remote == NULL) {
		py_remote = Py_None;
		Py_INCREF(py_remote);
	} else {
		if (object->remote == NULL) {
			py_remote = Py_None;
			Py_INCREF(py_remote);
		} else {
			py_remote = PyUnicode_Decode(object->remote, strlen(object->remote), "utf-8", "ignore");
		}
	}
	return py_remote;
}

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

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

static PyObject *py_wkssvc_NetrUseInfo2_get_asg_type(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_asg_type;
	py_asg_type = PyInt_FromLong(object->asg_type);
	return py_asg_type;
}

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

static PyObject *py_wkssvc_NetrUseInfo2_get_ref_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_ref_count;
	py_ref_count = PyInt_FromLong(object->ref_count);
	return py_ref_count;
}

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

static PyObject *py_wkssvc_NetrUseInfo2_get_use_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_use_count;
	py_use_count = PyInt_FromLong(object->use_count);
	return py_use_count;
}

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

static PyObject *py_wkssvc_NetrUseInfo2_get_user_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_user_name;
	if (object->user_name == NULL) {
		py_user_name = Py_None;
		Py_INCREF(py_user_name);
	} else {
		if (object->user_name == NULL) {
			py_user_name = Py_None;
			Py_INCREF(py_user_name);
		} else {
			py_user_name = PyUnicode_Decode(object->user_name, strlen(object->user_name), "utf-8", "ignore");
		}
	}
	return py_user_name;
}

static int py_wkssvc_NetrUseInfo2_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->user_name = NULL;
	} else {
		object->user_name = NULL;
		if (PyUnicode_Check(value)) {
			object->user_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->user_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_wkssvc_NetrUseInfo2_get_domain_name(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(obj);
	PyObject *py_domain_name;
	if (object->domain_name == NULL) {
		py_domain_name = Py_None;
		Py_INCREF(py_domain_name);
	} else {
		if (object->domain_name == NULL) {
			py_domain_name = Py_None;
			Py_INCREF(py_domain_name);
		} else {
			py_domain_name = PyUnicode_Decode(object->domain_name, strlen(object->domain_name), "utf-8", "ignore");
		}
	}
	return py_domain_name;
}

static int py_wkssvc_NetrUseInfo2_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo2 *object = (struct wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->domain_name = NULL;
	} else {
		object->domain_name = NULL;
		if (PyUnicode_Check(value)) {
			object->domain_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->domain_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_wkssvc_NetrUseInfo2_getsetters[] = {
	{ discard_const_p(char, "local"), py_wkssvc_NetrUseInfo2_get_local, py_wkssvc_NetrUseInfo2_set_local },
	{ discard_const_p(char, "remote"), py_wkssvc_NetrUseInfo2_get_remote, py_wkssvc_NetrUseInfo2_set_remote },
	{ discard_const_p(char, "password"), py_wkssvc_NetrUseInfo2_get_password, py_wkssvc_NetrUseInfo2_set_password },
	{ discard_const_p(char, "status"), py_wkssvc_NetrUseInfo2_get_status, py_wkssvc_NetrUseInfo2_set_status },
	{ discard_const_p(char, "asg_type"), py_wkssvc_NetrUseInfo2_get_asg_type, py_wkssvc_NetrUseInfo2_set_asg_type },
	{ discard_const_p(char, "ref_count"), py_wkssvc_NetrUseInfo2_get_ref_count, py_wkssvc_NetrUseInfo2_set_ref_count },
	{ discard_const_p(char, "use_count"), py_wkssvc_NetrUseInfo2_get_use_count, py_wkssvc_NetrUseInfo2_set_use_count },
	{ discard_const_p(char, "user_name"), py_wkssvc_NetrUseInfo2_get_user_name, py_wkssvc_NetrUseInfo2_set_user_name },
	{ discard_const_p(char, "domain_name"), py_wkssvc_NetrUseInfo2_get_domain_name, py_wkssvc_NetrUseInfo2_set_domain_name },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseInfo2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseInfo2",
	.tp_getset = py_wkssvc_NetrUseInfo2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseInfo2_new,
};


static PyObject *py_wkssvc_NetrUseInfo1_get_local(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo1 *object = (struct wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_local;
	if (object->local == NULL) {
		py_local = Py_None;
		Py_INCREF(py_local);
	} else {
		if (object->local == NULL) {
			py_local = Py_None;
			Py_INCREF(py_local);
		} else {
			py_local = PyUnicode_Decode(object->local, strlen(object->local), "utf-8", "ignore");
		}
	}
	return py_local;
}

static int py_wkssvc_NetrUseInfo1_set_local(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo1 *object = (struct wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->local = NULL;
	} else {
		object->local = NULL;
		if (PyUnicode_Check(value)) {
			object->local = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->local = 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_wkssvc_NetrUseInfo1_get_remote(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo1 *object = (struct wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_remote;
	if (object->remote == NULL) {
		py_remote = Py_None;
		Py_INCREF(py_remote);
	} else {
		if (object->remote == NULL) {
			py_remote = Py_None;
			Py_INCREF(py_remote);
		} else {
			py_remote = PyUnicode_Decode(object->remote, strlen(object->remote), "utf-8", "ignore");
		}
	}
	return py_remote;
}

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

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

static PyObject *py_wkssvc_NetrUseInfo1_get_asg_type(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo1 *object = (struct wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_asg_type;
	py_asg_type = PyInt_FromLong(object->asg_type);
	return py_asg_type;
}

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

static PyObject *py_wkssvc_NetrUseInfo1_get_ref_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo1 *object = (struct wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_ref_count;
	py_ref_count = PyInt_FromLong(object->ref_count);
	return py_ref_count;
}

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

static PyObject *py_wkssvc_NetrUseInfo1_get_use_count(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo1 *object = (struct wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(obj);
	PyObject *py_use_count;
	py_use_count = PyInt_FromLong(object->use_count);
	return py_use_count;
}

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

static PyGetSetDef py_wkssvc_NetrUseInfo1_getsetters[] = {
	{ discard_const_p(char, "local"), py_wkssvc_NetrUseInfo1_get_local, py_wkssvc_NetrUseInfo1_set_local },
	{ discard_const_p(char, "remote"), py_wkssvc_NetrUseInfo1_get_remote, py_wkssvc_NetrUseInfo1_set_remote },
	{ discard_const_p(char, "password"), py_wkssvc_NetrUseInfo1_get_password, py_wkssvc_NetrUseInfo1_set_password },
	{ discard_const_p(char, "status"), py_wkssvc_NetrUseInfo1_get_status, py_wkssvc_NetrUseInfo1_set_status },
	{ discard_const_p(char, "asg_type"), py_wkssvc_NetrUseInfo1_get_asg_type, py_wkssvc_NetrUseInfo1_set_asg_type },
	{ discard_const_p(char, "ref_count"), py_wkssvc_NetrUseInfo1_get_ref_count, py_wkssvc_NetrUseInfo1_set_ref_count },
	{ discard_const_p(char, "use_count"), py_wkssvc_NetrUseInfo1_get_use_count, py_wkssvc_NetrUseInfo1_set_use_count },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseInfo1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseInfo1",
	.tp_getset = py_wkssvc_NetrUseInfo1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseInfo1_new,
};


static PyObject *py_wkssvc_NetrUseInfo0_get_local(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo0 *object = (struct wkssvc_NetrUseInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_local;
	if (object->local == NULL) {
		py_local = Py_None;
		Py_INCREF(py_local);
	} else {
		if (object->local == NULL) {
			py_local = Py_None;
			Py_INCREF(py_local);
		} else {
			py_local = PyUnicode_Decode(object->local, strlen(object->local), "utf-8", "ignore");
		}
	}
	return py_local;
}

static int py_wkssvc_NetrUseInfo0_set_local(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo0 *object = (struct wkssvc_NetrUseInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->local = NULL;
	} else {
		object->local = NULL;
		if (PyUnicode_Check(value)) {
			object->local = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->local = 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_wkssvc_NetrUseInfo0_get_remote(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseInfo0 *object = (struct wkssvc_NetrUseInfo0 *)pytalloc_get_ptr(obj);
	PyObject *py_remote;
	if (object->remote == NULL) {
		py_remote = Py_None;
		Py_INCREF(py_remote);
	} else {
		if (object->remote == NULL) {
			py_remote = Py_None;
			Py_INCREF(py_remote);
		} else {
			py_remote = PyUnicode_Decode(object->remote, strlen(object->remote), "utf-8", "ignore");
		}
	}
	return py_remote;
}

static int py_wkssvc_NetrUseInfo0_set_remote(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseInfo0 *object = (struct wkssvc_NetrUseInfo0 *)pytalloc_get_ptr(py_obj);
	if (value == Py_None) {
		object->remote = NULL;
	} else {
		object->remote = NULL;
		if (PyUnicode_Check(value)) {
			object->remote = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
		} else if (PyString_Check(value)) {
			object->remote = 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_wkssvc_NetrUseInfo0_getsetters[] = {
	{ discard_const_p(char, "local"), py_wkssvc_NetrUseInfo0_get_local, py_wkssvc_NetrUseInfo0_set_local },
	{ discard_const_p(char, "remote"), py_wkssvc_NetrUseInfo0_get_remote, py_wkssvc_NetrUseInfo0_set_remote },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseInfo0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseInfo0",
	.tp_getset = py_wkssvc_NetrUseInfo0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseInfo0_new,
};

PyObject *py_import_wkssvc_NetrUseGetInfoCtr(TALLOC_CTX *mem_ctx, int level, union wkssvc_NetrUseGetInfoCtr *in)
{
	PyObject *ret;

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

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

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

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

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

union wkssvc_NetrUseGetInfoCtr *py_export_wkssvc_NetrUseGetInfoCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union wkssvc_NetrUseGetInfoCtr *ret = talloc_zero(mem_ctx, union wkssvc_NetrUseGetInfoCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->info0 = NULL;
			} else {
				ret->info0 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseInfo0_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 wkssvc_NetrUseInfo0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->info1 = NULL;
			} else {
				ret->info1 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseInfo1_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 wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->info2 = NULL;
			} else {
				ret->info2 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseInfo2_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 wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(in);
			}
			break;

		case 3:
			if (in == Py_None) {
				ret->info3 = NULL;
			} else {
				ret->info3 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseInfo3_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 wkssvc_NetrUseInfo3 *)pytalloc_get_ptr(in);
			}
			break;

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

	return ret;
}


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

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

static PyObject *py_wkssvc_NetrUseEnumCtr2_get_array(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseEnumCtr2 *object = (struct wkssvc_NetrUseEnumCtr2 *)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(&wkssvc_NetrUseInfo2_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_wkssvc_NetrUseEnumCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseEnumCtr2 *object = (struct wkssvc_NetrUseEnumCtr2 *)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(&wkssvc_NetrUseInfo2_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 wkssvc_NetrUseInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_NetrUseEnumCtr2_getsetters[] = {
	{ discard_const_p(char, "count"), py_wkssvc_NetrUseEnumCtr2_get_count, py_wkssvc_NetrUseEnumCtr2_set_count },
	{ discard_const_p(char, "array"), py_wkssvc_NetrUseEnumCtr2_get_array, py_wkssvc_NetrUseEnumCtr2_set_array },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseEnumCtr2_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseEnumCtr2",
	.tp_getset = py_wkssvc_NetrUseEnumCtr2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseEnumCtr2_new,
};


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

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

static PyObject *py_wkssvc_NetrUseEnumCtr1_get_array(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseEnumCtr1 *object = (struct wkssvc_NetrUseEnumCtr1 *)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(&wkssvc_NetrUseInfo1_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_wkssvc_NetrUseEnumCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseEnumCtr1 *object = (struct wkssvc_NetrUseEnumCtr1 *)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(&wkssvc_NetrUseInfo1_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 wkssvc_NetrUseInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_NetrUseEnumCtr1_getsetters[] = {
	{ discard_const_p(char, "count"), py_wkssvc_NetrUseEnumCtr1_get_count, py_wkssvc_NetrUseEnumCtr1_set_count },
	{ discard_const_p(char, "array"), py_wkssvc_NetrUseEnumCtr1_get_array, py_wkssvc_NetrUseEnumCtr1_set_array },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseEnumCtr1_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseEnumCtr1",
	.tp_getset = py_wkssvc_NetrUseEnumCtr1_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseEnumCtr1_new,
};


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

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

static PyObject *py_wkssvc_NetrUseEnumCtr0_get_array(PyObject *obj, void *closure)
{
	struct wkssvc_NetrUseEnumCtr0 *object = (struct wkssvc_NetrUseEnumCtr0 *)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(&wkssvc_NetrUseInfo0_Type, object->array, &object->array[array_cntr_1]);
				PyList_SetItem(py_array, array_cntr_1, py_array_1);
			}
		}
	}
	return py_array;
}

static int py_wkssvc_NetrUseEnumCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseEnumCtr0 *object = (struct wkssvc_NetrUseEnumCtr0 *)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(&wkssvc_NetrUseInfo0_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 wkssvc_NetrUseInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_NetrUseEnumCtr0_getsetters[] = {
	{ discard_const_p(char, "count"), py_wkssvc_NetrUseEnumCtr0_get_count, py_wkssvc_NetrUseEnumCtr0_set_count },
	{ discard_const_p(char, "array"), py_wkssvc_NetrUseEnumCtr0_get_array, py_wkssvc_NetrUseEnumCtr0_set_array },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseEnumCtr0_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseEnumCtr0",
	.tp_getset = py_wkssvc_NetrUseEnumCtr0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseEnumCtr0_new,
};

PyObject *py_import_wkssvc_NetrUseEnumCtr(TALLOC_CTX *mem_ctx, int level, union wkssvc_NetrUseEnumCtr *in)
{
	PyObject *ret;

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

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

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

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

union wkssvc_NetrUseEnumCtr *py_export_wkssvc_NetrUseEnumCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union wkssvc_NetrUseEnumCtr *ret = talloc_zero(mem_ctx, union wkssvc_NetrUseEnumCtr);
	switch (level) {
		case 0:
			if (in == Py_None) {
				ret->ctr0 = NULL;
			} else {
				ret->ctr0 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseEnumCtr0_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 wkssvc_NetrUseEnumCtr0 *)pytalloc_get_ptr(in);
			}
			break;

		case 1:
			if (in == Py_None) {
				ret->ctr1 = NULL;
			} else {
				ret->ctr1 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseEnumCtr1_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 wkssvc_NetrUseEnumCtr1 *)pytalloc_get_ptr(in);
			}
			break;

		case 2:
			if (in == Py_None) {
				ret->ctr2 = NULL;
			} else {
				ret->ctr2 = NULL;
				PY_CHECK_TYPE(&wkssvc_NetrUseEnumCtr2_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 wkssvc_NetrUseEnumCtr2 *)pytalloc_get_ptr(in);
			}
			break;

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

	return ret;
}


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

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

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

static int py_wkssvc_NetrUseEnumInfo_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrUseEnumInfo *object = (struct wkssvc_NetrUseEnumInfo *)pytalloc_get_ptr(py_obj);
	{
		union wkssvc_NetrUseEnumCtr *ctr_switch_0;
		ctr_switch_0 = py_export_wkssvc_NetrUseEnumCtr(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_wkssvc_NetrUseEnumInfo_getsetters[] = {
	{ discard_const_p(char, "level"), py_wkssvc_NetrUseEnumInfo_get_level, py_wkssvc_NetrUseEnumInfo_set_level },
	{ discard_const_p(char, "ctr"), py_wkssvc_NetrUseEnumInfo_get_ctr, py_wkssvc_NetrUseEnumInfo_set_ctr },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrUseEnumInfo_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrUseEnumInfo",
	.tp_getset = py_wkssvc_NetrUseEnumInfo_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrUseEnumInfo_new,
};


static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown1(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown1;
	py_unknown1 = PyLong_FromLongLong(object->unknown1);
	return py_unknown1;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown1 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown1 = 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_wkssvc_NetrWorkstationStatistics_get_unknown2(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown2;
	py_unknown2 = PyLong_FromLongLong(object->unknown2);
	return py_unknown2;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown2 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown2 = 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_wkssvc_NetrWorkstationStatistics_get_unknown3(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown3;
	py_unknown3 = PyLong_FromLongLong(object->unknown3);
	return py_unknown3;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown3(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown3 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown3 = 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_wkssvc_NetrWorkstationStatistics_get_unknown4(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown4;
	py_unknown4 = PyLong_FromLongLong(object->unknown4);
	return py_unknown4;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown4(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown4 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown4 = 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_wkssvc_NetrWorkstationStatistics_get_unknown5(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown5;
	py_unknown5 = PyLong_FromLongLong(object->unknown5);
	return py_unknown5;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown5(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown5 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown5 = 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_wkssvc_NetrWorkstationStatistics_get_unknown6(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown6;
	py_unknown6 = PyLong_FromLongLong(object->unknown6);
	return py_unknown6;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown6(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown6 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown6 = 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_wkssvc_NetrWorkstationStatistics_get_unknown7(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown7;
	py_unknown7 = PyLong_FromLongLong(object->unknown7);
	return py_unknown7;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown7(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown7 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown7 = 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_wkssvc_NetrWorkstationStatistics_get_unknown8(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown8;
	py_unknown8 = PyLong_FromLongLong(object->unknown8);
	return py_unknown8;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown8(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown8 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown8 = 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_wkssvc_NetrWorkstationStatistics_get_unknown9(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown9;
	py_unknown9 = PyLong_FromLongLong(object->unknown9);
	return py_unknown9;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown9(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown9 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown9 = 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_wkssvc_NetrWorkstationStatistics_get_unknown10(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown10;
	py_unknown10 = PyLong_FromLongLong(object->unknown10);
	return py_unknown10;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown10(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown10 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown10 = 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_wkssvc_NetrWorkstationStatistics_get_unknown11(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown11;
	py_unknown11 = PyLong_FromLongLong(object->unknown11);
	return py_unknown11;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown11(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown11 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown11 = 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_wkssvc_NetrWorkstationStatistics_get_unknown12(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown12;
	py_unknown12 = PyLong_FromLongLong(object->unknown12);
	return py_unknown12;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown12(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown12 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown12 = 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_wkssvc_NetrWorkstationStatistics_get_unknown13(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown13;
	py_unknown13 = PyLong_FromLongLong(object->unknown13);
	return py_unknown13;
}

static int py_wkssvc_NetrWorkstationStatistics_set_unknown13(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(py_obj);
	if (PyLong_Check(value)) {
		object->unknown13 = PyLong_AsLongLong(value);
	} else if (PyInt_Check(value)) {
		object->unknown13 = 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_wkssvc_NetrWorkstationStatistics_get_unknown14(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown14;
	py_unknown14 = PyInt_FromLong(object->unknown14);
	return py_unknown14;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown15(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown15;
	py_unknown15 = PyInt_FromLong(object->unknown15);
	return py_unknown15;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown16(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown16;
	py_unknown16 = PyInt_FromLong(object->unknown16);
	return py_unknown16;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown17(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown17;
	py_unknown17 = PyInt_FromLong(object->unknown17);
	return py_unknown17;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown18(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown18;
	py_unknown18 = PyInt_FromLong(object->unknown18);
	return py_unknown18;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown19(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown19;
	py_unknown19 = PyInt_FromLong(object->unknown19);
	return py_unknown19;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown20(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown20;
	py_unknown20 = PyInt_FromLong(object->unknown20);
	return py_unknown20;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown21(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown21;
	py_unknown21 = PyInt_FromLong(object->unknown21);
	return py_unknown21;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown22(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown22;
	py_unknown22 = PyInt_FromLong(object->unknown22);
	return py_unknown22;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown23(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown23;
	py_unknown23 = PyInt_FromLong(object->unknown23);
	return py_unknown23;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown24(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown24;
	py_unknown24 = PyInt_FromLong(object->unknown24);
	return py_unknown24;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown25(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown25;
	py_unknown25 = PyInt_FromLong(object->unknown25);
	return py_unknown25;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown26(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown26;
	py_unknown26 = PyInt_FromLong(object->unknown26);
	return py_unknown26;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown27(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown27;
	py_unknown27 = PyInt_FromLong(object->unknown27);
	return py_unknown27;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown28(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown28;
	py_unknown28 = PyInt_FromLong(object->unknown28);
	return py_unknown28;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown29(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown29;
	py_unknown29 = PyInt_FromLong(object->unknown29);
	return py_unknown29;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown30(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown30;
	py_unknown30 = PyInt_FromLong(object->unknown30);
	return py_unknown30;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown31(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown31;
	py_unknown31 = PyInt_FromLong(object->unknown31);
	return py_unknown31;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown32(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown32;
	py_unknown32 = PyInt_FromLong(object->unknown32);
	return py_unknown32;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown33(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown33;
	py_unknown33 = PyInt_FromLong(object->unknown33);
	return py_unknown33;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown34(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown34;
	py_unknown34 = PyInt_FromLong(object->unknown34);
	return py_unknown34;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown35(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown35;
	py_unknown35 = PyInt_FromLong(object->unknown35);
	return py_unknown35;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown36(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown36;
	py_unknown36 = PyInt_FromLong(object->unknown36);
	return py_unknown36;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown37(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown37;
	py_unknown37 = PyInt_FromLong(object->unknown37);
	return py_unknown37;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown38(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown38;
	py_unknown38 = PyInt_FromLong(object->unknown38);
	return py_unknown38;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown39(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown39;
	py_unknown39 = PyInt_FromLong(object->unknown39);
	return py_unknown39;
}

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

static PyObject *py_wkssvc_NetrWorkstationStatistics_get_unknown40(PyObject *obj, void *closure)
{
	struct wkssvc_NetrWorkstationStatistics *object = (struct wkssvc_NetrWorkstationStatistics *)pytalloc_get_ptr(obj);
	PyObject *py_unknown40;
	py_unknown40 = PyInt_FromLong(object->unknown40);
	return py_unknown40;
}

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

static PyGetSetDef py_wkssvc_NetrWorkstationStatistics_getsetters[] = {
	{ discard_const_p(char, "unknown1"), py_wkssvc_NetrWorkstationStatistics_get_unknown1, py_wkssvc_NetrWorkstationStatistics_set_unknown1 },
	{ discard_const_p(char, "unknown2"), py_wkssvc_NetrWorkstationStatistics_get_unknown2, py_wkssvc_NetrWorkstationStatistics_set_unknown2 },
	{ discard_const_p(char, "unknown3"), py_wkssvc_NetrWorkstationStatistics_get_unknown3, py_wkssvc_NetrWorkstationStatistics_set_unknown3 },
	{ discard_const_p(char, "unknown4"), py_wkssvc_NetrWorkstationStatistics_get_unknown4, py_wkssvc_NetrWorkstationStatistics_set_unknown4 },
	{ discard_const_p(char, "unknown5"), py_wkssvc_NetrWorkstationStatistics_get_unknown5, py_wkssvc_NetrWorkstationStatistics_set_unknown5 },
	{ discard_const_p(char, "unknown6"), py_wkssvc_NetrWorkstationStatistics_get_unknown6, py_wkssvc_NetrWorkstationStatistics_set_unknown6 },
	{ discard_const_p(char, "unknown7"), py_wkssvc_NetrWorkstationStatistics_get_unknown7, py_wkssvc_NetrWorkstationStatistics_set_unknown7 },
	{ discard_const_p(char, "unknown8"), py_wkssvc_NetrWorkstationStatistics_get_unknown8, py_wkssvc_NetrWorkstationStatistics_set_unknown8 },
	{ discard_const_p(char, "unknown9"), py_wkssvc_NetrWorkstationStatistics_get_unknown9, py_wkssvc_NetrWorkstationStatistics_set_unknown9 },
	{ discard_const_p(char, "unknown10"), py_wkssvc_NetrWorkstationStatistics_get_unknown10, py_wkssvc_NetrWorkstationStatistics_set_unknown10 },
	{ discard_const_p(char, "unknown11"), py_wkssvc_NetrWorkstationStatistics_get_unknown11, py_wkssvc_NetrWorkstationStatistics_set_unknown11 },
	{ discard_const_p(char, "unknown12"), py_wkssvc_NetrWorkstationStatistics_get_unknown12, py_wkssvc_NetrWorkstationStatistics_set_unknown12 },
	{ discard_const_p(char, "unknown13"), py_wkssvc_NetrWorkstationStatistics_get_unknown13, py_wkssvc_NetrWorkstationStatistics_set_unknown13 },
	{ discard_const_p(char, "unknown14"), py_wkssvc_NetrWorkstationStatistics_get_unknown14, py_wkssvc_NetrWorkstationStatistics_set_unknown14 },
	{ discard_const_p(char, "unknown15"), py_wkssvc_NetrWorkstationStatistics_get_unknown15, py_wkssvc_NetrWorkstationStatistics_set_unknown15 },
	{ discard_const_p(char, "unknown16"), py_wkssvc_NetrWorkstationStatistics_get_unknown16, py_wkssvc_NetrWorkstationStatistics_set_unknown16 },
	{ discard_const_p(char, "unknown17"), py_wkssvc_NetrWorkstationStatistics_get_unknown17, py_wkssvc_NetrWorkstationStatistics_set_unknown17 },
	{ discard_const_p(char, "unknown18"), py_wkssvc_NetrWorkstationStatistics_get_unknown18, py_wkssvc_NetrWorkstationStatistics_set_unknown18 },
	{ discard_const_p(char, "unknown19"), py_wkssvc_NetrWorkstationStatistics_get_unknown19, py_wkssvc_NetrWorkstationStatistics_set_unknown19 },
	{ discard_const_p(char, "unknown20"), py_wkssvc_NetrWorkstationStatistics_get_unknown20, py_wkssvc_NetrWorkstationStatistics_set_unknown20 },
	{ discard_const_p(char, "unknown21"), py_wkssvc_NetrWorkstationStatistics_get_unknown21, py_wkssvc_NetrWorkstationStatistics_set_unknown21 },
	{ discard_const_p(char, "unknown22"), py_wkssvc_NetrWorkstationStatistics_get_unknown22, py_wkssvc_NetrWorkstationStatistics_set_unknown22 },
	{ discard_const_p(char, "unknown23"), py_wkssvc_NetrWorkstationStatistics_get_unknown23, py_wkssvc_NetrWorkstationStatistics_set_unknown23 },
	{ discard_const_p(char, "unknown24"), py_wkssvc_NetrWorkstationStatistics_get_unknown24, py_wkssvc_NetrWorkstationStatistics_set_unknown24 },
	{ discard_const_p(char, "unknown25"), py_wkssvc_NetrWorkstationStatistics_get_unknown25, py_wkssvc_NetrWorkstationStatistics_set_unknown25 },
	{ discard_const_p(char, "unknown26"), py_wkssvc_NetrWorkstationStatistics_get_unknown26, py_wkssvc_NetrWorkstationStatistics_set_unknown26 },
	{ discard_const_p(char, "unknown27"), py_wkssvc_NetrWorkstationStatistics_get_unknown27, py_wkssvc_NetrWorkstationStatistics_set_unknown27 },
	{ discard_const_p(char, "unknown28"), py_wkssvc_NetrWorkstationStatistics_get_unknown28, py_wkssvc_NetrWorkstationStatistics_set_unknown28 },
	{ discard_const_p(char, "unknown29"), py_wkssvc_NetrWorkstationStatistics_get_unknown29, py_wkssvc_NetrWorkstationStatistics_set_unknown29 },
	{ discard_const_p(char, "unknown30"), py_wkssvc_NetrWorkstationStatistics_get_unknown30, py_wkssvc_NetrWorkstationStatistics_set_unknown30 },
	{ discard_const_p(char, "unknown31"), py_wkssvc_NetrWorkstationStatistics_get_unknown31, py_wkssvc_NetrWorkstationStatistics_set_unknown31 },
	{ discard_const_p(char, "unknown32"), py_wkssvc_NetrWorkstationStatistics_get_unknown32, py_wkssvc_NetrWorkstationStatistics_set_unknown32 },
	{ discard_const_p(char, "unknown33"), py_wkssvc_NetrWorkstationStatistics_get_unknown33, py_wkssvc_NetrWorkstationStatistics_set_unknown33 },
	{ discard_const_p(char, "unknown34"), py_wkssvc_NetrWorkstationStatistics_get_unknown34, py_wkssvc_NetrWorkstationStatistics_set_unknown34 },
	{ discard_const_p(char, "unknown35"), py_wkssvc_NetrWorkstationStatistics_get_unknown35, py_wkssvc_NetrWorkstationStatistics_set_unknown35 },
	{ discard_const_p(char, "unknown36"), py_wkssvc_NetrWorkstationStatistics_get_unknown36, py_wkssvc_NetrWorkstationStatistics_set_unknown36 },
	{ discard_const_p(char, "unknown37"), py_wkssvc_NetrWorkstationStatistics_get_unknown37, py_wkssvc_NetrWorkstationStatistics_set_unknown37 },
	{ discard_const_p(char, "unknown38"), py_wkssvc_NetrWorkstationStatistics_get_unknown38, py_wkssvc_NetrWorkstationStatistics_set_unknown38 },
	{ discard_const_p(char, "unknown39"), py_wkssvc_NetrWorkstationStatistics_get_unknown39, py_wkssvc_NetrWorkstationStatistics_set_unknown39 },
	{ discard_const_p(char, "unknown40"), py_wkssvc_NetrWorkstationStatistics_get_unknown40, py_wkssvc_NetrWorkstationStatistics_set_unknown40 },
	{ NULL }
};

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


static PyTypeObject wkssvc_NetrWorkstationStatistics_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.NetrWorkstationStatistics",
	.tp_getset = py_wkssvc_NetrWorkstationStatistics_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_NetrWorkstationStatistics_new,
};


static PyObject *py_wkssvc_PasswordBuffer_get_data(PyObject *obj, void *closure)
{
	struct wkssvc_PasswordBuffer *object = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(obj);
	PyObject *py_data;
	py_data = PyList_New(524);
	if (py_data == NULL) {
		return NULL;
	}
	{
		int data_cntr_0;
		for (data_cntr_0 = 0; data_cntr_0 < 524; data_cntr_0++) {
			PyObject *py_data_0;
			py_data_0 = PyInt_FromLong(object->data[data_cntr_0]);
			PyList_SetItem(py_data, data_cntr_0, py_data_0);
		}
	}
	return py_data;
}

static int py_wkssvc_PasswordBuffer_set_data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_PasswordBuffer *object = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_obj);
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int data_cntr_0;
		for (data_cntr_0 = 0; data_cntr_0 < PyList_GET_SIZE(value); data_cntr_0++) {
			PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, data_cntr_0), return -1;);
			object->data[data_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, data_cntr_0));
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_PasswordBuffer_getsetters[] = {
	{ discard_const_p(char, "data"), py_wkssvc_PasswordBuffer_get_data, py_wkssvc_PasswordBuffer_set_data },
	{ NULL }
};

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


static PyTypeObject wkssvc_PasswordBuffer_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.PasswordBuffer",
	.tp_getset = py_wkssvc_PasswordBuffer_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_PasswordBuffer_new,
};


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

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

static PyObject *py_wkssvc_ComputerNamesCtr_get_computer_name(PyObject *obj, void *closure)
{
	struct wkssvc_ComputerNamesCtr *object = (struct wkssvc_ComputerNamesCtr *)pytalloc_get_ptr(obj);
	PyObject *py_computer_name;
	if (object->computer_name == NULL) {
		py_computer_name = Py_None;
		Py_INCREF(py_computer_name);
	} else {
		py_computer_name = PyList_New(object->count);
		if (py_computer_name == NULL) {
			return NULL;
		}
		{
			int computer_name_cntr_1;
			for (computer_name_cntr_1 = 0; computer_name_cntr_1 < object->count; computer_name_cntr_1++) {
				PyObject *py_computer_name_1;
				py_computer_name_1 = pytalloc_reference_ex(lsa_String_Type, object->computer_name, &object->computer_name[computer_name_cntr_1]);
				PyList_SetItem(py_computer_name, computer_name_cntr_1, py_computer_name_1);
			}
		}
	}
	return py_computer_name;
}

static int py_wkssvc_ComputerNamesCtr_set_computer_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct wkssvc_ComputerNamesCtr *object = (struct wkssvc_ComputerNamesCtr *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->computer_name);
	if (value == Py_None) {
		object->computer_name = NULL;
	} else {
		object->computer_name = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int computer_name_cntr_1;
			object->computer_name = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->computer_name, PyList_GET_SIZE(value));
			if (!object->computer_name) { return -1;; }
			talloc_set_name_const(object->computer_name, "ARRAY: object->computer_name");
			for (computer_name_cntr_1 = 0; computer_name_cntr_1 < PyList_GET_SIZE(value); computer_name_cntr_1++) {
				PY_CHECK_TYPE(lsa_String_Type, PyList_GET_ITEM(value, computer_name_cntr_1), return -1;);
				if (talloc_reference(object->computer_name, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, computer_name_cntr_1))) == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->computer_name[computer_name_cntr_1] = *(struct lsa_String *)pytalloc_get_ptr(PyList_GET_ITEM(value, computer_name_cntr_1));
			}
		}
	}
	return 0;
}

static PyGetSetDef py_wkssvc_ComputerNamesCtr_getsetters[] = {
	{ discard_const_p(char, "count"), py_wkssvc_ComputerNamesCtr_get_count, py_wkssvc_ComputerNamesCtr_set_count },
	{ discard_const_p(char, "computer_name"), py_wkssvc_ComputerNamesCtr_get_computer_name, py_wkssvc_ComputerNamesCtr_set_computer_name },
	{ NULL }
};

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


static PyTypeObject wkssvc_ComputerNamesCtr_Type = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.ComputerNamesCtr",
	.tp_getset = py_wkssvc_ComputerNamesCtr_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_basicsize = sizeof(pytalloc_Object),
	.tp_new = py_wkssvc_ComputerNamesCtr_new,
};


static bool pack_py_wkssvc_NetWkstaGetInfo_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetWkstaGetInfo *r)
{
	PyObject *py_server_name;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_name", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:wkssvc_NetWkstaGetInfo", discard_const_p(char *, kwnames), &py_server_name, &py_level)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_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_wkssvc_NetWkstaGetInfo_args_out(struct wkssvc_NetWkstaGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_wkssvc_NetWkstaInfo(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_wkssvc_NetWkstaSetInfo_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetWkstaSetInfo *r)
{
	PyObject *py_server_name;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_parm_error;
	const char *kwnames[] = {
		"server_name", "level", "info", "parm_error", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetWkstaSetInfo", discard_const_p(char *, kwnames), &py_server_name, &py_level, &py_info, &py_parm_error)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_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 wkssvc_NetWkstaInfo *info_switch_1;
		info_switch_1 = py_export_wkssvc_NetWkstaInfo(r, r->in.level, py_info);
		if (info_switch_1 == NULL) {
			return false;
		}
		r->in.info = info_switch_1;
	}
	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_wkssvc_NetWkstaSetInfo_args_out(struct wkssvc_NetWkstaSetInfo *r)
{
	PyObject *result;
	PyObject *py_parm_error;
	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_wkssvc_NetWkstaEnumUsers_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetWkstaEnumUsers *r)
{
	PyObject *py_server_name;
	PyObject *py_info;
	PyObject *py_prefmaxlen;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_name", "info", "prefmaxlen", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetWkstaEnumUsers", discard_const_p(char *, kwnames), &py_server_name, &py_info, &py_prefmaxlen, &py_resume_handle)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.info = talloc_ptrtype(r, r->in.info);
	PY_CHECK_TYPE(&wkssvc_NetWkstaEnumUsersInfo_Type, py_info, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info = (struct wkssvc_NetWkstaEnumUsersInfo *)pytalloc_get_ptr(py_info);
	PY_CHECK_TYPE(&PyInt_Type, py_prefmaxlen, return false;);
	r->in.prefmaxlen = PyInt_AsLong(py_prefmaxlen);
	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_wkssvc_NetWkstaEnumUsers_args_out(struct wkssvc_NetWkstaEnumUsers *r)
{
	PyObject *result;
	PyObject *py_info;
	PyObject *py_entries_read;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info = pytalloc_reference_ex(&wkssvc_NetWkstaEnumUsersInfo_Type, r->out.info, r->out.info);
	PyTuple_SetItem(result, 0, py_info);
	py_entries_read = PyInt_FromLong(*r->out.entries_read);
	PyTuple_SetItem(result, 1, py_entries_read);
	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_wkssvc_NetrWkstaUserGetInfo_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrWkstaUserGetInfo *r)
{
	PyObject *py_unknown;
	PyObject *py_level;
	const char *kwnames[] = {
		"unknown", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:wkssvc_NetrWkstaUserGetInfo", discard_const_p(char *, kwnames), &py_unknown, &py_level)) {
		return false;
	}

	if (py_unknown == Py_None) {
		r->in.unknown = NULL;
	} else {
		r->in.unknown = NULL;
		if (PyUnicode_Check(py_unknown)) {
			r->in.unknown = PyString_AS_STRING(PyUnicode_AsEncodedString(py_unknown, "utf-8", "ignore"));
		} else if (PyString_Check(py_unknown)) {
			r->in.unknown = PyString_AS_STRING(py_unknown);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_unknown)->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_wkssvc_NetrWkstaUserGetInfo_args_out(struct wkssvc_NetrWkstaUserGetInfo *r)
{
	PyObject *result;
	PyObject *py_info;
	py_info = py_import_wkssvc_NetrWkstaUserInfo(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_wkssvc_NetrWkstaUserSetInfo_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrWkstaUserSetInfo *r)
{
	PyObject *py_unknown;
	PyObject *py_level;
	PyObject *py_info;
	PyObject *py_parm_err;
	const char *kwnames[] = {
		"unknown", "level", "info", "parm_err", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrWkstaUserSetInfo", discard_const_p(char *, kwnames), &py_unknown, &py_level, &py_info, &py_parm_err)) {
		return false;
	}

	if (py_unknown == Py_None) {
		r->in.unknown = NULL;
	} else {
		r->in.unknown = NULL;
		if (PyUnicode_Check(py_unknown)) {
			r->in.unknown = PyString_AS_STRING(PyUnicode_AsEncodedString(py_unknown, "utf-8", "ignore"));
		} else if (PyString_Check(py_unknown)) {
			r->in.unknown = PyString_AS_STRING(py_unknown);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_unknown)->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 wkssvc_NetrWkstaUserInfo *info_switch_1;
		info_switch_1 = py_export_wkssvc_NetrWkstaUserInfo(r, r->in.level, py_info);
		if (info_switch_1 == NULL) {
			return false;
		}
		r->in.info = info_switch_1;
	}
	if (py_parm_err == Py_None) {
		r->in.parm_err = NULL;
	} else {
		r->in.parm_err = talloc_ptrtype(r, r->in.parm_err);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_err, return false;);
		*r->in.parm_err = PyInt_AsLong(py_parm_err);
	}
	return true;
}

static PyObject *unpack_py_wkssvc_NetrWkstaUserSetInfo_args_out(struct wkssvc_NetrWkstaUserSetInfo *r)
{
	PyObject *result;
	PyObject *py_parm_err;
	if (r->out.parm_err == NULL) {
		py_parm_err = Py_None;
		Py_INCREF(py_parm_err);
	} else {
		py_parm_err = PyInt_FromLong(*r->out.parm_err);
	}
	result = py_parm_err;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetWkstaTransportEnum_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetWkstaTransportEnum *r)
{
	PyObject *py_server_name;
	PyObject *py_info;
	PyObject *py_max_buffer;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_name", "info", "max_buffer", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetWkstaTransportEnum", discard_const_p(char *, kwnames), &py_server_name, &py_info, &py_max_buffer, &py_resume_handle)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.info = talloc_ptrtype(r, r->in.info);
	PY_CHECK_TYPE(&wkssvc_NetWkstaTransportInfo_Type, py_info, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info = (struct wkssvc_NetWkstaTransportInfo *)pytalloc_get_ptr(py_info);
	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_wkssvc_NetWkstaTransportEnum_args_out(struct wkssvc_NetWkstaTransportEnum *r)
{
	PyObject *result;
	PyObject *py_info;
	PyObject *py_total_entries;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info = pytalloc_reference_ex(&wkssvc_NetWkstaTransportInfo_Type, r->out.info, r->out.info);
	PyTuple_SetItem(result, 0, py_info);
	py_total_entries = PyInt_FromLong(*r->out.total_entries);
	PyTuple_SetItem(result, 1, py_total_entries);
	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_wkssvc_NetrWkstaTransportAdd_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrWkstaTransportAdd *r)
{
	PyObject *py_server_name;
	PyObject *py_level;
	PyObject *py_info0;
	PyObject *py_parm_err;
	const char *kwnames[] = {
		"server_name", "level", "info0", "parm_err", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrWkstaTransportAdd", discard_const_p(char *, kwnames), &py_server_name, &py_level, &py_info0, &py_parm_err)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->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(&wkssvc_NetWkstaTransportInfo0_Type, py_info0, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info0)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info0 = (struct wkssvc_NetWkstaTransportInfo0 *)pytalloc_get_ptr(py_info0);
	if (py_parm_err == Py_None) {
		r->in.parm_err = NULL;
	} else {
		r->in.parm_err = talloc_ptrtype(r, r->in.parm_err);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_err, return false;);
		*r->in.parm_err = PyInt_AsLong(py_parm_err);
	}
	return true;
}

static PyObject *unpack_py_wkssvc_NetrWkstaTransportAdd_args_out(struct wkssvc_NetrWkstaTransportAdd *r)
{
	PyObject *result;
	PyObject *py_parm_err;
	if (r->out.parm_err == NULL) {
		py_parm_err = Py_None;
		Py_INCREF(py_parm_err);
	} else {
		py_parm_err = PyInt_FromLong(*r->out.parm_err);
	}
	result = py_parm_err;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetrWkstaTransportDel_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrWkstaTransportDel *r)
{
	PyObject *py_server_name;
	PyObject *py_transport_name;
	PyObject *py_unknown3;
	const char *kwnames[] = {
		"server_name", "transport_name", "unknown3", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:wkssvc_NetrWkstaTransportDel", discard_const_p(char *, kwnames), &py_server_name, &py_transport_name, &py_unknown3)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_transport_name == Py_None) {
		r->in.transport_name = NULL;
	} else {
		r->in.transport_name = NULL;
		if (PyUnicode_Check(py_transport_name)) {
			r->in.transport_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_transport_name)) {
			r->in.transport_name = PyString_AS_STRING(py_transport_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport_name)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_unknown3, return false;);
	r->in.unknown3 = PyInt_AsLong(py_unknown3);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrWkstaTransportDel_args_out(struct wkssvc_NetrWkstaTransportDel *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_wkssvc_NetrUseAdd_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrUseAdd *r)
{
	PyObject *py_server_name;
	PyObject *py_level;
	PyObject *py_ctr;
	PyObject *py_parm_err;
	const char *kwnames[] = {
		"server_name", "level", "ctr", "parm_err", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrUseAdd", discard_const_p(char *, kwnames), &py_server_name, &py_level, &py_ctr, &py_parm_err)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
	r->in.level = PyInt_AsLong(py_level);
	r->in.ctr = talloc_ptrtype(r, r->in.ctr);
	{
		union wkssvc_NetrUseGetInfoCtr *ctr_switch_1;
		ctr_switch_1 = py_export_wkssvc_NetrUseGetInfoCtr(r, r->in.level, py_ctr);
		if (ctr_switch_1 == NULL) {
			return false;
		}
		r->in.ctr = ctr_switch_1;
	}
	if (py_parm_err == Py_None) {
		r->in.parm_err = NULL;
	} else {
		r->in.parm_err = talloc_ptrtype(r, r->in.parm_err);
		PY_CHECK_TYPE(&PyInt_Type, py_parm_err, return false;);
		*r->in.parm_err = PyInt_AsLong(py_parm_err);
	}
	return true;
}

static PyObject *unpack_py_wkssvc_NetrUseAdd_args_out(struct wkssvc_NetrUseAdd *r)
{
	PyObject *result;
	PyObject *py_parm_err;
	if (r->out.parm_err == NULL) {
		py_parm_err = Py_None;
		Py_INCREF(py_parm_err);
	} else {
		py_parm_err = PyInt_FromLong(*r->out.parm_err);
	}
	result = py_parm_err;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetrUseGetInfo_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrUseGetInfo *r)
{
	PyObject *py_server_name;
	PyObject *py_use_name;
	PyObject *py_level;
	const char *kwnames[] = {
		"server_name", "use_name", "level", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:wkssvc_NetrUseGetInfo", discard_const_p(char *, kwnames), &py_server_name, &py_use_name, &py_level)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.use_name = talloc_ptrtype(r, r->in.use_name);
	if (PyUnicode_Check(py_use_name)) {
		r->in.use_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_use_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_use_name)) {
		r->in.use_name = PyString_AS_STRING(py_use_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_use_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_wkssvc_NetrUseGetInfo_args_out(struct wkssvc_NetrUseGetInfo *r)
{
	PyObject *result;
	PyObject *py_ctr;
	py_ctr = py_import_wkssvc_NetrUseGetInfoCtr(r->out.ctr, r->in.level, r->out.ctr);
	if (py_ctr == NULL) {
		return NULL;
	}
	result = py_ctr;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetrUseDel_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrUseDel *r)
{
	PyObject *py_server_name;
	PyObject *py_use_name;
	PyObject *py_force_cond;
	const char *kwnames[] = {
		"server_name", "use_name", "force_cond", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:wkssvc_NetrUseDel", discard_const_p(char *, kwnames), &py_server_name, &py_use_name, &py_force_cond)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.use_name = talloc_ptrtype(r, r->in.use_name);
	if (PyUnicode_Check(py_use_name)) {
		r->in.use_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_use_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_use_name)) {
		r->in.use_name = PyString_AS_STRING(py_use_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_use_name)->tp_name);
		return false;
	}
	PY_CHECK_TYPE(&PyInt_Type, py_force_cond, return false;);
	r->in.force_cond = PyInt_AsLong(py_force_cond);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrUseDel_args_out(struct wkssvc_NetrUseDel *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_wkssvc_NetrUseEnum_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrUseEnum *r)
{
	PyObject *py_server_name;
	PyObject *py_info;
	PyObject *py_prefmaxlen;
	PyObject *py_resume_handle;
	const char *kwnames[] = {
		"server_name", "info", "prefmaxlen", "resume_handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrUseEnum", discard_const_p(char *, kwnames), &py_server_name, &py_info, &py_prefmaxlen, &py_resume_handle)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.info = talloc_ptrtype(r, r->in.info);
	PY_CHECK_TYPE(&wkssvc_NetrUseEnumInfo_Type, py_info, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.info = (struct wkssvc_NetrUseEnumInfo *)pytalloc_get_ptr(py_info);
	PY_CHECK_TYPE(&PyInt_Type, py_prefmaxlen, return false;);
	r->in.prefmaxlen = PyInt_AsLong(py_prefmaxlen);
	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_wkssvc_NetrUseEnum_args_out(struct wkssvc_NetrUseEnum *r)
{
	PyObject *result;
	PyObject *py_info;
	PyObject *py_entries_read;
	PyObject *py_resume_handle;
	result = PyTuple_New(3);
	py_info = pytalloc_reference_ex(&wkssvc_NetrUseEnumInfo_Type, r->out.info, r->out.info);
	PyTuple_SetItem(result, 0, py_info);
	py_entries_read = PyInt_FromLong(*r->out.entries_read);
	PyTuple_SetItem(result, 1, py_entries_read);
	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_wkssvc_NetrMessageBufferSend_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrMessageBufferSend *r)
{
	PyObject *py_server_name;
	PyObject *py_message_name;
	PyObject *py_message_sender_name;
	PyObject *py_message_buffer;
	const char *kwnames[] = {
		"server_name", "message_name", "message_sender_name", "message_buffer", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrMessageBufferSend", discard_const_p(char *, kwnames), &py_server_name, &py_message_name, &py_message_sender_name, &py_message_buffer)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.message_name = talloc_ptrtype(r, r->in.message_name);
	if (PyUnicode_Check(py_message_name)) {
		r->in.message_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_message_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_message_name)) {
		r->in.message_name = PyString_AS_STRING(py_message_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_message_name)->tp_name);
		return false;
	}
	if (py_message_sender_name == Py_None) {
		r->in.message_sender_name = NULL;
	} else {
		r->in.message_sender_name = NULL;
		if (PyUnicode_Check(py_message_sender_name)) {
			r->in.message_sender_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_message_sender_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_message_sender_name)) {
			r->in.message_sender_name = PyString_AS_STRING(py_message_sender_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_message_sender_name)->tp_name);
			return false;
		}
	}
	r->in.message_buffer = talloc_ptrtype(r, r->in.message_buffer);
	PY_CHECK_TYPE(&PyList_Type, py_message_buffer, return false;);
	{
		int message_buffer_cntr_1;
		r->in.message_buffer = talloc_array_ptrtype(r, r->in.message_buffer, PyList_GET_SIZE(py_message_buffer));
		if (!r->in.message_buffer) { return false;; }
		talloc_set_name_const(r->in.message_buffer, "ARRAY: r->in.message_buffer");
		for (message_buffer_cntr_1 = 0; message_buffer_cntr_1 < PyList_GET_SIZE(py_message_buffer); message_buffer_cntr_1++) {
			PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(py_message_buffer, message_buffer_cntr_1), return false;);
			r->in.message_buffer[message_buffer_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(py_message_buffer, message_buffer_cntr_1));
		}
	}
	PY_CHECK_TYPE(&PyList_Type, py_message_buffer, return false;);
	r->in.message_size = PyList_GET_SIZE(py_message_buffer);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrMessageBufferSend_args_out(struct wkssvc_NetrMessageBufferSend *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_wkssvc_NetrWorkstationStatisticsGet_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrWorkstationStatisticsGet *r)
{
	PyObject *py_server_name;
	PyObject *py_unknown2;
	PyObject *py_unknown3;
	PyObject *py_unknown4;
	const char *kwnames[] = {
		"server_name", "unknown2", "unknown3", "unknown4", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrWorkstationStatisticsGet", discard_const_p(char *, kwnames), &py_server_name, &py_unknown2, &py_unknown3, &py_unknown4)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_unknown2 == Py_None) {
		r->in.unknown2 = NULL;
	} else {
		r->in.unknown2 = NULL;
		if (PyUnicode_Check(py_unknown2)) {
			r->in.unknown2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_unknown2, "utf-8", "ignore"));
		} else if (PyString_Check(py_unknown2)) {
			r->in.unknown2 = PyString_AS_STRING(py_unknown2);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_unknown2)->tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyInt_Type, py_unknown3, return false;);
	r->in.unknown3 = PyInt_AsLong(py_unknown3);
	PY_CHECK_TYPE(&PyInt_Type, py_unknown4, return false;);
	r->in.unknown4 = PyInt_AsLong(py_unknown4);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrWorkstationStatisticsGet_args_out(struct wkssvc_NetrWorkstationStatisticsGet *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(&wkssvc_NetrWorkstationStatistics_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_wkssvc_NetrLogonDomainNameAdd_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrLogonDomainNameAdd *r)
{
	PyObject *py_domain_name;
	const char *kwnames[] = {
		"domain_name", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:wkssvc_NetrLogonDomainNameAdd", discard_const_p(char *, kwnames), &py_domain_name)) {
		return false;
	}

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

static PyObject *unpack_py_wkssvc_NetrLogonDomainNameAdd_args_out(struct wkssvc_NetrLogonDomainNameAdd *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_wkssvc_NetrLogonDomainNameDel_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrLogonDomainNameDel *r)
{
	PyObject *py_domain_name;
	const char *kwnames[] = {
		"domain_name", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:wkssvc_NetrLogonDomainNameDel", discard_const_p(char *, kwnames), &py_domain_name)) {
		return false;
	}

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

static PyObject *unpack_py_wkssvc_NetrLogonDomainNameDel_args_out(struct wkssvc_NetrLogonDomainNameDel *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_wkssvc_NetrJoinDomain_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrJoinDomain *r)
{
	PyObject *py_server_name;
	PyObject *py_domain_name;
	PyObject *py_account_ou;
	PyObject *py_Account;
	PyObject *py_password;
	PyObject *py_join_flags;
	const char *kwnames[] = {
		"server_name", "domain_name", "account_ou", "Account", "password", "join_flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:wkssvc_NetrJoinDomain", discard_const_p(char *, kwnames), &py_server_name, &py_domain_name, &py_account_ou, &py_Account, &py_password, &py_join_flags)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.domain_name = talloc_ptrtype(r, r->in.domain_name);
	if (PyUnicode_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_domain_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(py_domain_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_domain_name)->tp_name);
		return false;
	}
	if (py_account_ou == Py_None) {
		r->in.account_ou = NULL;
	} else {
		r->in.account_ou = NULL;
		if (PyUnicode_Check(py_account_ou)) {
			r->in.account_ou = PyString_AS_STRING(PyUnicode_AsEncodedString(py_account_ou, "utf-8", "ignore"));
		} else if (PyString_Check(py_account_ou)) {
			r->in.account_ou = PyString_AS_STRING(py_account_ou);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_account_ou)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_password == Py_None) {
		r->in.password = NULL;
	} else {
		r->in.password = NULL;
		if (PyUnicode_Check(py_password)) {
			r->in.password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_password, "utf-8", "ignore"));
		} else if (PyString_Check(py_password)) {
			r->in.password = PyString_AS_STRING(py_password);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_password)->tp_name);
			return false;
		}
	}
	if (PyLong_Check(py_join_flags)) {
		r->in.join_flags = PyLong_AsLongLong(py_join_flags);
	} else if (PyInt_Check(py_join_flags)) {
		r->in.join_flags = PyInt_AsLong(py_join_flags);
	} 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_wkssvc_NetrJoinDomain_args_out(struct wkssvc_NetrJoinDomain *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_wkssvc_NetrUnjoinDomain_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrUnjoinDomain *r)
{
	PyObject *py_server_name;
	PyObject *py_Account;
	PyObject *py_password;
	PyObject *py_unjoin_flags;
	const char *kwnames[] = {
		"server_name", "Account", "password", "unjoin_flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrUnjoinDomain", discard_const_p(char *, kwnames), &py_server_name, &py_Account, &py_password, &py_unjoin_flags)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_password == Py_None) {
		r->in.password = NULL;
	} else {
		r->in.password = NULL;
		if (PyUnicode_Check(py_password)) {
			r->in.password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_password, "utf-8", "ignore"));
		} else if (PyString_Check(py_password)) {
			r->in.password = PyString_AS_STRING(py_password);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_password)->tp_name);
			return false;
		}
	}
	if (PyLong_Check(py_unjoin_flags)) {
		r->in.unjoin_flags = PyLong_AsLongLong(py_unjoin_flags);
	} else if (PyInt_Check(py_unjoin_flags)) {
		r->in.unjoin_flags = PyInt_AsLong(py_unjoin_flags);
	} 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_wkssvc_NetrUnjoinDomain_args_out(struct wkssvc_NetrUnjoinDomain *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_wkssvc_NetrRenameMachineInDomain_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrRenameMachineInDomain *r)
{
	PyObject *py_server_name;
	PyObject *py_NewMachineName;
	PyObject *py_Account;
	PyObject *py_password;
	PyObject *py_RenameOptions;
	const char *kwnames[] = {
		"server_name", "NewMachineName", "Account", "password", "RenameOptions", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrRenameMachineInDomain", discard_const_p(char *, kwnames), &py_server_name, &py_NewMachineName, &py_Account, &py_password, &py_RenameOptions)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_NewMachineName == Py_None) {
		r->in.NewMachineName = NULL;
	} else {
		r->in.NewMachineName = NULL;
		if (PyUnicode_Check(py_NewMachineName)) {
			r->in.NewMachineName = PyString_AS_STRING(PyUnicode_AsEncodedString(py_NewMachineName, "utf-8", "ignore"));
		} else if (PyString_Check(py_NewMachineName)) {
			r->in.NewMachineName = PyString_AS_STRING(py_NewMachineName);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_NewMachineName)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_password == Py_None) {
		r->in.password = NULL;
	} else {
		r->in.password = NULL;
		if (PyUnicode_Check(py_password)) {
			r->in.password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_password, "utf-8", "ignore"));
		} else if (PyString_Check(py_password)) {
			r->in.password = PyString_AS_STRING(py_password);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_password)->tp_name);
			return false;
		}
	}
	if (PyLong_Check(py_RenameOptions)) {
		r->in.RenameOptions = PyLong_AsLongLong(py_RenameOptions);
	} else if (PyInt_Check(py_RenameOptions)) {
		r->in.RenameOptions = PyInt_AsLong(py_RenameOptions);
	} 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_wkssvc_NetrRenameMachineInDomain_args_out(struct wkssvc_NetrRenameMachineInDomain *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_wkssvc_NetrValidateName_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrValidateName *r)
{
	PyObject *py_server_name;
	PyObject *py_name;
	PyObject *py_Account;
	PyObject *py_Password;
	PyObject *py_name_type;
	const char *kwnames[] = {
		"server_name", "name", "Account", "Password", "name_type", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrValidateName", discard_const_p(char *, kwnames), &py_server_name, &py_name, &py_Account, &py_Password, &py_name_type)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.name = talloc_ptrtype(r, r->in.name);
	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;
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_Password == Py_None) {
		r->in.Password = NULL;
	} else {
		r->in.Password = NULL;
		if (PyUnicode_Check(py_Password)) {
			r->in.Password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Password, "utf-8", "ignore"));
		} else if (PyString_Check(py_Password)) {
			r->in.Password = PyString_AS_STRING(py_Password);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Password)->tp_name);
			return false;
		}
	}
	if (PyLong_Check(py_name_type)) {
		r->in.name_type = PyLong_AsLongLong(py_name_type);
	} else if (PyInt_Check(py_name_type)) {
		r->in.name_type = PyInt_AsLong(py_name_type);
	} 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_wkssvc_NetrValidateName_args_out(struct wkssvc_NetrValidateName *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_wkssvc_NetrGetJoinInformation_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrGetJoinInformation *r)
{
	PyObject *py_server_name;
	PyObject *py_name_buffer;
	const char *kwnames[] = {
		"server_name", "name_buffer", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:wkssvc_NetrGetJoinInformation", discard_const_p(char *, kwnames), &py_server_name, &py_name_buffer)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.name_buffer = talloc_ptrtype(r, r->in.name_buffer);
	if (py_name_buffer == Py_None) {
		*r->in.name_buffer = NULL;
	} else {
		*r->in.name_buffer = NULL;
		if (PyUnicode_Check(py_name_buffer)) {
			*r->in.name_buffer = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name_buffer, "utf-8", "ignore"));
		} else if (PyString_Check(py_name_buffer)) {
			*r->in.name_buffer = PyString_AS_STRING(py_name_buffer);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name_buffer)->tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_wkssvc_NetrGetJoinInformation_args_out(struct wkssvc_NetrGetJoinInformation *r)
{
	PyObject *result;
	PyObject *py_name_buffer;
	PyObject *py_name_type;
	result = PyTuple_New(2);
	if (*r->out.name_buffer == NULL) {
		py_name_buffer = Py_None;
		Py_INCREF(py_name_buffer);
	} else {
		if (*r->out.name_buffer == NULL) {
			py_name_buffer = Py_None;
			Py_INCREF(py_name_buffer);
		} else {
			py_name_buffer = PyUnicode_Decode(*r->out.name_buffer, strlen(*r->out.name_buffer), "utf-8", "ignore");
		}
	}
	PyTuple_SetItem(result, 0, py_name_buffer);
	py_name_type = PyInt_FromLong(*r->out.name_type);
	PyTuple_SetItem(result, 1, py_name_type);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetrGetJoinableOus_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrGetJoinableOus *r)
{
	PyObject *py_server_name;
	PyObject *py_domain_name;
	PyObject *py_Account;
	PyObject *py_unknown;
	PyObject *py_num_ous;
	const char *kwnames[] = {
		"server_name", "domain_name", "Account", "unknown", "num_ous", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrGetJoinableOus", discard_const_p(char *, kwnames), &py_server_name, &py_domain_name, &py_Account, &py_unknown, &py_num_ous)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.domain_name = talloc_ptrtype(r, r->in.domain_name);
	if (PyUnicode_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_domain_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(py_domain_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_domain_name)->tp_name);
		return false;
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_unknown == Py_None) {
		r->in.unknown = NULL;
	} else {
		r->in.unknown = NULL;
		if (PyUnicode_Check(py_unknown)) {
			r->in.unknown = PyString_AS_STRING(PyUnicode_AsEncodedString(py_unknown, "utf-8", "ignore"));
		} else if (PyString_Check(py_unknown)) {
			r->in.unknown = PyString_AS_STRING(py_unknown);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_unknown)->tp_name);
			return false;
		}
	}
	r->in.num_ous = talloc_ptrtype(r, r->in.num_ous);
	PY_CHECK_TYPE(&PyInt_Type, py_num_ous, return false;);
	*r->in.num_ous = PyInt_AsLong(py_num_ous);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrGetJoinableOus_args_out(struct wkssvc_NetrGetJoinableOus *r)
{
	PyObject *result;
	PyObject *py_num_ous;
	PyObject *py_ous;
	result = PyTuple_New(2);
	py_num_ous = PyInt_FromLong(*r->out.num_ous);
	PyTuple_SetItem(result, 0, py_num_ous);
	if (*r->out.ous == NULL) {
		py_ous = Py_None;
		Py_INCREF(py_ous);
	} else {
		py_ous = PyList_New(*r->out.num_ous);
		if (py_ous == NULL) {
			return NULL;
		}
		{
			int ous_cntr_2;
			for (ous_cntr_2 = 0; ous_cntr_2 < *r->out.num_ous; ous_cntr_2++) {
				PyObject *py_ous_2;
				if (*r->out.ous[ous_cntr_2] == NULL) {
					py_ous_2 = Py_None;
					Py_INCREF(py_ous_2);
				} else {
					if (*r->out.ous[ous_cntr_2] == NULL) {
						py_ous_2 = Py_None;
						Py_INCREF(py_ous_2);
					} else {
						py_ous_2 = PyUnicode_Decode(*r->out.ous[ous_cntr_2], strlen(*r->out.ous[ous_cntr_2]), "utf-8", "ignore");
					}
				}
				PyList_SetItem(py_ous, ous_cntr_2, py_ous_2);
			}
		}
	}
	PyTuple_SetItem(result, 1, py_ous);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetrJoinDomain2_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrJoinDomain2 *r)
{
	PyObject *py_server_name;
	PyObject *py_domain_name;
	PyObject *py_account_ou;
	PyObject *py_admin_account;
	PyObject *py_encrypted_password;
	PyObject *py_join_flags;
	const char *kwnames[] = {
		"server_name", "domain_name", "account_ou", "admin_account", "encrypted_password", "join_flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:wkssvc_NetrJoinDomain2", discard_const_p(char *, kwnames), &py_server_name, &py_domain_name, &py_account_ou, &py_admin_account, &py_encrypted_password, &py_join_flags)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.domain_name = talloc_ptrtype(r, r->in.domain_name);
	if (PyUnicode_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_domain_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(py_domain_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_domain_name)->tp_name);
		return false;
	}
	if (py_account_ou == Py_None) {
		r->in.account_ou = NULL;
	} else {
		r->in.account_ou = NULL;
		if (PyUnicode_Check(py_account_ou)) {
			r->in.account_ou = PyString_AS_STRING(PyUnicode_AsEncodedString(py_account_ou, "utf-8", "ignore"));
		} else if (PyString_Check(py_account_ou)) {
			r->in.account_ou = PyString_AS_STRING(py_account_ou);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_account_ou)->tp_name);
			return false;
		}
	}
	if (py_admin_account == Py_None) {
		r->in.admin_account = NULL;
	} else {
		r->in.admin_account = NULL;
		if (PyUnicode_Check(py_admin_account)) {
			r->in.admin_account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_admin_account, "utf-8", "ignore"));
		} else if (PyString_Check(py_admin_account)) {
			r->in.admin_account = PyString_AS_STRING(py_admin_account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_admin_account)->tp_name);
			return false;
		}
	}
	if (py_encrypted_password == Py_None) {
		r->in.encrypted_password = NULL;
	} else {
		r->in.encrypted_password = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_encrypted_password, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_encrypted_password)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.encrypted_password = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_encrypted_password);
	}
	if (PyLong_Check(py_join_flags)) {
		r->in.join_flags = PyLong_AsLongLong(py_join_flags);
	} else if (PyInt_Check(py_join_flags)) {
		r->in.join_flags = PyInt_AsLong(py_join_flags);
	} 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_wkssvc_NetrJoinDomain2_args_out(struct wkssvc_NetrJoinDomain2 *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_wkssvc_NetrUnjoinDomain2_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrUnjoinDomain2 *r)
{
	PyObject *py_server_name;
	PyObject *py_account;
	PyObject *py_encrypted_password;
	PyObject *py_unjoin_flags;
	const char *kwnames[] = {
		"server_name", "account", "encrypted_password", "unjoin_flags", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:wkssvc_NetrUnjoinDomain2", discard_const_p(char *, kwnames), &py_server_name, &py_account, &py_encrypted_password, &py_unjoin_flags)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_account == Py_None) {
		r->in.account = NULL;
	} else {
		r->in.account = NULL;
		if (PyUnicode_Check(py_account)) {
			r->in.account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_account, "utf-8", "ignore"));
		} else if (PyString_Check(py_account)) {
			r->in.account = PyString_AS_STRING(py_account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_account)->tp_name);
			return false;
		}
	}
	if (py_encrypted_password == Py_None) {
		r->in.encrypted_password = NULL;
	} else {
		r->in.encrypted_password = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_encrypted_password, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_encrypted_password)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.encrypted_password = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_encrypted_password);
	}
	if (PyLong_Check(py_unjoin_flags)) {
		r->in.unjoin_flags = PyLong_AsLongLong(py_unjoin_flags);
	} else if (PyInt_Check(py_unjoin_flags)) {
		r->in.unjoin_flags = PyInt_AsLong(py_unjoin_flags);
	} 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_wkssvc_NetrUnjoinDomain2_args_out(struct wkssvc_NetrUnjoinDomain2 *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_wkssvc_NetrRenameMachineInDomain2_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrRenameMachineInDomain2 *r)
{
	PyObject *py_server_name;
	PyObject *py_NewMachineName;
	PyObject *py_Account;
	PyObject *py_EncryptedPassword;
	PyObject *py_RenameOptions;
	const char *kwnames[] = {
		"server_name", "NewMachineName", "Account", "EncryptedPassword", "RenameOptions", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrRenameMachineInDomain2", discard_const_p(char *, kwnames), &py_server_name, &py_NewMachineName, &py_Account, &py_EncryptedPassword, &py_RenameOptions)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_NewMachineName == Py_None) {
		r->in.NewMachineName = NULL;
	} else {
		r->in.NewMachineName = NULL;
		if (PyUnicode_Check(py_NewMachineName)) {
			r->in.NewMachineName = PyString_AS_STRING(PyUnicode_AsEncodedString(py_NewMachineName, "utf-8", "ignore"));
		} else if (PyString_Check(py_NewMachineName)) {
			r->in.NewMachineName = PyString_AS_STRING(py_NewMachineName);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_NewMachineName)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_EncryptedPassword == Py_None) {
		r->in.EncryptedPassword = NULL;
	} else {
		r->in.EncryptedPassword = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_EncryptedPassword, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_EncryptedPassword)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.EncryptedPassword = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_EncryptedPassword);
	}
	if (PyLong_Check(py_RenameOptions)) {
		r->in.RenameOptions = PyLong_AsLongLong(py_RenameOptions);
	} else if (PyInt_Check(py_RenameOptions)) {
		r->in.RenameOptions = PyInt_AsLong(py_RenameOptions);
	} 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_wkssvc_NetrRenameMachineInDomain2_args_out(struct wkssvc_NetrRenameMachineInDomain2 *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_wkssvc_NetrValidateName2_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrValidateName2 *r)
{
	PyObject *py_server_name;
	PyObject *py_name;
	PyObject *py_Account;
	PyObject *py_EncryptedPassword;
	PyObject *py_name_type;
	const char *kwnames[] = {
		"server_name", "name", "Account", "EncryptedPassword", "name_type", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrValidateName2", discard_const_p(char *, kwnames), &py_server_name, &py_name, &py_Account, &py_EncryptedPassword, &py_name_type)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.name = talloc_ptrtype(r, r->in.name);
	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;
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_EncryptedPassword == Py_None) {
		r->in.EncryptedPassword = NULL;
	} else {
		r->in.EncryptedPassword = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_EncryptedPassword, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_EncryptedPassword)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.EncryptedPassword = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_EncryptedPassword);
	}
	if (PyLong_Check(py_name_type)) {
		r->in.name_type = PyLong_AsLongLong(py_name_type);
	} else if (PyInt_Check(py_name_type)) {
		r->in.name_type = PyInt_AsLong(py_name_type);
	} 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_wkssvc_NetrValidateName2_args_out(struct wkssvc_NetrValidateName2 *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_wkssvc_NetrGetJoinableOus2_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrGetJoinableOus2 *r)
{
	PyObject *py_server_name;
	PyObject *py_domain_name;
	PyObject *py_Account;
	PyObject *py_EncryptedPassword;
	PyObject *py_num_ous;
	const char *kwnames[] = {
		"server_name", "domain_name", "Account", "EncryptedPassword", "num_ous", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrGetJoinableOus2", discard_const_p(char *, kwnames), &py_server_name, &py_domain_name, &py_Account, &py_EncryptedPassword, &py_num_ous)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	r->in.domain_name = talloc_ptrtype(r, r->in.domain_name);
	if (PyUnicode_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_domain_name, "utf-8", "ignore"));
	} else if (PyString_Check(py_domain_name)) {
		r->in.domain_name = PyString_AS_STRING(py_domain_name);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_domain_name)->tp_name);
		return false;
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_EncryptedPassword == Py_None) {
		r->in.EncryptedPassword = NULL;
	} else {
		r->in.EncryptedPassword = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_EncryptedPassword, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_EncryptedPassword)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.EncryptedPassword = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_EncryptedPassword);
	}
	r->in.num_ous = talloc_ptrtype(r, r->in.num_ous);
	PY_CHECK_TYPE(&PyInt_Type, py_num_ous, return false;);
	*r->in.num_ous = PyInt_AsLong(py_num_ous);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrGetJoinableOus2_args_out(struct wkssvc_NetrGetJoinableOus2 *r)
{
	PyObject *result;
	PyObject *py_num_ous;
	PyObject *py_ous;
	result = PyTuple_New(2);
	py_num_ous = PyInt_FromLong(*r->out.num_ous);
	PyTuple_SetItem(result, 0, py_num_ous);
	if (*r->out.ous == NULL) {
		py_ous = Py_None;
		Py_INCREF(py_ous);
	} else {
		py_ous = PyList_New(*r->out.num_ous);
		if (py_ous == NULL) {
			return NULL;
		}
		{
			int ous_cntr_2;
			for (ous_cntr_2 = 0; ous_cntr_2 < *r->out.num_ous; ous_cntr_2++) {
				PyObject *py_ous_2;
				if (*r->out.ous[ous_cntr_2] == NULL) {
					py_ous_2 = Py_None;
					Py_INCREF(py_ous_2);
				} else {
					if (*r->out.ous[ous_cntr_2] == NULL) {
						py_ous_2 = Py_None;
						Py_INCREF(py_ous_2);
					} else {
						py_ous_2 = PyUnicode_Decode(*r->out.ous[ous_cntr_2], strlen(*r->out.ous[ous_cntr_2]), "utf-8", "ignore");
					}
				}
				PyList_SetItem(py_ous, ous_cntr_2, py_ous_2);
			}
		}
	}
	PyTuple_SetItem(result, 1, py_ous);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

static bool pack_py_wkssvc_NetrAddAlternateComputerName_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrAddAlternateComputerName *r)
{
	PyObject *py_server_name;
	PyObject *py_NewAlternateMachineName;
	PyObject *py_Account;
	PyObject *py_EncryptedPassword;
	PyObject *py_Reserved;
	const char *kwnames[] = {
		"server_name", "NewAlternateMachineName", "Account", "EncryptedPassword", "Reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrAddAlternateComputerName", discard_const_p(char *, kwnames), &py_server_name, &py_NewAlternateMachineName, &py_Account, &py_EncryptedPassword, &py_Reserved)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_NewAlternateMachineName == Py_None) {
		r->in.NewAlternateMachineName = NULL;
	} else {
		r->in.NewAlternateMachineName = NULL;
		if (PyUnicode_Check(py_NewAlternateMachineName)) {
			r->in.NewAlternateMachineName = PyString_AS_STRING(PyUnicode_AsEncodedString(py_NewAlternateMachineName, "utf-8", "ignore"));
		} else if (PyString_Check(py_NewAlternateMachineName)) {
			r->in.NewAlternateMachineName = PyString_AS_STRING(py_NewAlternateMachineName);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_NewAlternateMachineName)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_EncryptedPassword == Py_None) {
		r->in.EncryptedPassword = NULL;
	} else {
		r->in.EncryptedPassword = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_EncryptedPassword, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_EncryptedPassword)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.EncryptedPassword = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_EncryptedPassword);
	}
	PY_CHECK_TYPE(&PyInt_Type, py_Reserved, return false;);
	r->in.Reserved = PyInt_AsLong(py_Reserved);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrAddAlternateComputerName_args_out(struct wkssvc_NetrAddAlternateComputerName *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_wkssvc_NetrRemoveAlternateComputerName_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrRemoveAlternateComputerName *r)
{
	PyObject *py_server_name;
	PyObject *py_AlternateMachineNameToRemove;
	PyObject *py_Account;
	PyObject *py_EncryptedPassword;
	PyObject *py_Reserved;
	const char *kwnames[] = {
		"server_name", "AlternateMachineNameToRemove", "Account", "EncryptedPassword", "Reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrRemoveAlternateComputerName", discard_const_p(char *, kwnames), &py_server_name, &py_AlternateMachineNameToRemove, &py_Account, &py_EncryptedPassword, &py_Reserved)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_AlternateMachineNameToRemove == Py_None) {
		r->in.AlternateMachineNameToRemove = NULL;
	} else {
		r->in.AlternateMachineNameToRemove = NULL;
		if (PyUnicode_Check(py_AlternateMachineNameToRemove)) {
			r->in.AlternateMachineNameToRemove = PyString_AS_STRING(PyUnicode_AsEncodedString(py_AlternateMachineNameToRemove, "utf-8", "ignore"));
		} else if (PyString_Check(py_AlternateMachineNameToRemove)) {
			r->in.AlternateMachineNameToRemove = PyString_AS_STRING(py_AlternateMachineNameToRemove);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_AlternateMachineNameToRemove)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_EncryptedPassword == Py_None) {
		r->in.EncryptedPassword = NULL;
	} else {
		r->in.EncryptedPassword = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_EncryptedPassword, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_EncryptedPassword)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.EncryptedPassword = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_EncryptedPassword);
	}
	PY_CHECK_TYPE(&PyInt_Type, py_Reserved, return false;);
	r->in.Reserved = PyInt_AsLong(py_Reserved);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrRemoveAlternateComputerName_args_out(struct wkssvc_NetrRemoveAlternateComputerName *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_wkssvc_NetrSetPrimaryComputername_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrSetPrimaryComputername *r)
{
	PyObject *py_server_name;
	PyObject *py_primary_name;
	PyObject *py_Account;
	PyObject *py_EncryptedPassword;
	PyObject *py_Reserved;
	const char *kwnames[] = {
		"server_name", "primary_name", "Account", "EncryptedPassword", "Reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:wkssvc_NetrSetPrimaryComputername", discard_const_p(char *, kwnames), &py_server_name, &py_primary_name, &py_Account, &py_EncryptedPassword, &py_Reserved)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (py_primary_name == Py_None) {
		r->in.primary_name = NULL;
	} else {
		r->in.primary_name = NULL;
		if (PyUnicode_Check(py_primary_name)) {
			r->in.primary_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_primary_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_primary_name)) {
			r->in.primary_name = PyString_AS_STRING(py_primary_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_primary_name)->tp_name);
			return false;
		}
	}
	if (py_Account == Py_None) {
		r->in.Account = NULL;
	} else {
		r->in.Account = NULL;
		if (PyUnicode_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_Account, "utf-8", "ignore"));
		} else if (PyString_Check(py_Account)) {
			r->in.Account = PyString_AS_STRING(py_Account);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_Account)->tp_name);
			return false;
		}
	}
	if (py_EncryptedPassword == Py_None) {
		r->in.EncryptedPassword = NULL;
	} else {
		r->in.EncryptedPassword = NULL;
		PY_CHECK_TYPE(&wkssvc_PasswordBuffer_Type, py_EncryptedPassword, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_EncryptedPassword)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.EncryptedPassword = (struct wkssvc_PasswordBuffer *)pytalloc_get_ptr(py_EncryptedPassword);
	}
	PY_CHECK_TYPE(&PyInt_Type, py_Reserved, return false;);
	r->in.Reserved = PyInt_AsLong(py_Reserved);
	return true;
}

static PyObject *unpack_py_wkssvc_NetrSetPrimaryComputername_args_out(struct wkssvc_NetrSetPrimaryComputername *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_wkssvc_NetrEnumerateComputerNames_args_in(PyObject *args, PyObject *kwargs, struct wkssvc_NetrEnumerateComputerNames *r)
{
	PyObject *py_server_name;
	PyObject *py_name_type;
	PyObject *py_Reserved;
	const char *kwnames[] = {
		"server_name", "name_type", "Reserved", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:wkssvc_NetrEnumerateComputerNames", discard_const_p(char *, kwnames), &py_server_name, &py_name_type, &py_Reserved)) {
		return false;
	}

	if (py_server_name == Py_None) {
		r->in.server_name = NULL;
	} else {
		r->in.server_name = NULL;
		if (PyUnicode_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_name, "utf-8", "ignore"));
		} else if (PyString_Check(py_server_name)) {
			r->in.server_name = PyString_AS_STRING(py_server_name);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_name)->tp_name);
			return false;
		}
	}
	if (PyLong_Check(py_name_type)) {
		r->in.name_type = PyLong_AsLongLong(py_name_type);
	} else if (PyInt_Check(py_name_type)) {
		r->in.name_type = PyInt_AsLong(py_name_type);
	} else {
		PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
		  PyInt_Type.tp_name, PyLong_Type.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_wkssvc_NetrEnumerateComputerNames_args_out(struct wkssvc_NetrEnumerateComputerNames *r)
{
	PyObject *result;
	PyObject *py_ctr;
	if (*r->out.ctr == NULL) {
		py_ctr = Py_None;
		Py_INCREF(py_ctr);
	} else {
		py_ctr = pytalloc_reference_ex(&wkssvc_ComputerNamesCtr_Type, *r->out.ctr, *r->out.ctr);
	}
	result = py_ctr;
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

const struct PyNdrRpcMethodDef py_ndr_wkssvc_methods[] = {
	{ "NetWkstaGetInfo", "S.NetWkstaGetInfo(server_name, level) -> info", (py_dcerpc_call_fn)dcerpc_wkssvc_NetWkstaGetInfo_r, (py_data_pack_fn)pack_py_wkssvc_NetWkstaGetInfo_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetWkstaGetInfo_args_out, 0, &ndr_table_wkssvc },
	{ "NetWkstaSetInfo", "S.NetWkstaSetInfo(server_name, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_wkssvc_NetWkstaSetInfo_r, (py_data_pack_fn)pack_py_wkssvc_NetWkstaSetInfo_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetWkstaSetInfo_args_out, 1, &ndr_table_wkssvc },
	{ "NetWkstaEnumUsers", "S.NetWkstaEnumUsers(server_name, info, prefmaxlen, resume_handle) -> (info, entries_read, resume_handle)", (py_dcerpc_call_fn)dcerpc_wkssvc_NetWkstaEnumUsers_r, (py_data_pack_fn)pack_py_wkssvc_NetWkstaEnumUsers_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetWkstaEnumUsers_args_out, 2, &ndr_table_wkssvc },
	{ "NetrWkstaUserGetInfo", "S.NetrWkstaUserGetInfo(unknown, level) -> info", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrWkstaUserGetInfo_r, (py_data_pack_fn)pack_py_wkssvc_NetrWkstaUserGetInfo_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrWkstaUserGetInfo_args_out, 3, &ndr_table_wkssvc },
	{ "NetrWkstaUserSetInfo", "S.NetrWkstaUserSetInfo(unknown, level, info, parm_err) -> parm_err", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrWkstaUserSetInfo_r, (py_data_pack_fn)pack_py_wkssvc_NetrWkstaUserSetInfo_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrWkstaUserSetInfo_args_out, 4, &ndr_table_wkssvc },
	{ "NetWkstaTransportEnum", "S.NetWkstaTransportEnum(server_name, info, max_buffer, resume_handle) -> (info, total_entries, resume_handle)", (py_dcerpc_call_fn)dcerpc_wkssvc_NetWkstaTransportEnum_r, (py_data_pack_fn)pack_py_wkssvc_NetWkstaTransportEnum_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetWkstaTransportEnum_args_out, 5, &ndr_table_wkssvc },
	{ "NetrWkstaTransportAdd", "S.NetrWkstaTransportAdd(server_name, level, info0, parm_err) -> parm_err", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrWkstaTransportAdd_r, (py_data_pack_fn)pack_py_wkssvc_NetrWkstaTransportAdd_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrWkstaTransportAdd_args_out, 6, &ndr_table_wkssvc },
	{ "NetrWkstaTransportDel", "S.NetrWkstaTransportDel(server_name, transport_name, unknown3) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrWkstaTransportDel_r, (py_data_pack_fn)pack_py_wkssvc_NetrWkstaTransportDel_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrWkstaTransportDel_args_out, 7, &ndr_table_wkssvc },
	{ "NetrUseAdd", "S.NetrUseAdd(server_name, level, ctr, parm_err) -> parm_err", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrUseAdd_r, (py_data_pack_fn)pack_py_wkssvc_NetrUseAdd_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrUseAdd_args_out, 8, &ndr_table_wkssvc },
	{ "NetrUseGetInfo", "S.NetrUseGetInfo(server_name, use_name, level) -> ctr", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrUseGetInfo_r, (py_data_pack_fn)pack_py_wkssvc_NetrUseGetInfo_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrUseGetInfo_args_out, 9, &ndr_table_wkssvc },
	{ "NetrUseDel", "S.NetrUseDel(server_name, use_name, force_cond) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrUseDel_r, (py_data_pack_fn)pack_py_wkssvc_NetrUseDel_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrUseDel_args_out, 10, &ndr_table_wkssvc },
	{ "NetrUseEnum", "S.NetrUseEnum(server_name, info, prefmaxlen, resume_handle) -> (info, entries_read, resume_handle)", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrUseEnum_r, (py_data_pack_fn)pack_py_wkssvc_NetrUseEnum_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrUseEnum_args_out, 11, &ndr_table_wkssvc },
	{ "NetrMessageBufferSend", "S.NetrMessageBufferSend(server_name, message_name, message_sender_name, message_buffer) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrMessageBufferSend_r, (py_data_pack_fn)pack_py_wkssvc_NetrMessageBufferSend_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrMessageBufferSend_args_out, 12, &ndr_table_wkssvc },
	{ "NetrWorkstationStatisticsGet", "S.NetrWorkstationStatisticsGet(server_name, unknown2, unknown3, unknown4) -> info", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrWorkstationStatisticsGet_r, (py_data_pack_fn)pack_py_wkssvc_NetrWorkstationStatisticsGet_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrWorkstationStatisticsGet_args_out, 13, &ndr_table_wkssvc },
	{ "NetrLogonDomainNameAdd", "S.NetrLogonDomainNameAdd(domain_name) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrLogonDomainNameAdd_r, (py_data_pack_fn)pack_py_wkssvc_NetrLogonDomainNameAdd_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrLogonDomainNameAdd_args_out, 14, &ndr_table_wkssvc },
	{ "NetrLogonDomainNameDel", "S.NetrLogonDomainNameDel(domain_name) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrLogonDomainNameDel_r, (py_data_pack_fn)pack_py_wkssvc_NetrLogonDomainNameDel_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrLogonDomainNameDel_args_out, 15, &ndr_table_wkssvc },
	{ "NetrJoinDomain", "S.NetrJoinDomain(server_name, domain_name, account_ou, Account, password, join_flags) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrJoinDomain_r, (py_data_pack_fn)pack_py_wkssvc_NetrJoinDomain_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrJoinDomain_args_out, 16, &ndr_table_wkssvc },
	{ "NetrUnjoinDomain", "S.NetrUnjoinDomain(server_name, Account, password, unjoin_flags) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrUnjoinDomain_r, (py_data_pack_fn)pack_py_wkssvc_NetrUnjoinDomain_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrUnjoinDomain_args_out, 17, &ndr_table_wkssvc },
	{ "NetrRenameMachineInDomain", "S.NetrRenameMachineInDomain(server_name, NewMachineName, Account, password, RenameOptions) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrRenameMachineInDomain_r, (py_data_pack_fn)pack_py_wkssvc_NetrRenameMachineInDomain_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrRenameMachineInDomain_args_out, 18, &ndr_table_wkssvc },
	{ "NetrValidateName", "S.NetrValidateName(server_name, name, Account, Password, name_type) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrValidateName_r, (py_data_pack_fn)pack_py_wkssvc_NetrValidateName_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrValidateName_args_out, 19, &ndr_table_wkssvc },
	{ "NetrGetJoinInformation", "S.NetrGetJoinInformation(server_name, name_buffer) -> (name_buffer, name_type)", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrGetJoinInformation_r, (py_data_pack_fn)pack_py_wkssvc_NetrGetJoinInformation_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrGetJoinInformation_args_out, 20, &ndr_table_wkssvc },
	{ "NetrGetJoinableOus", "S.NetrGetJoinableOus(server_name, domain_name, Account, unknown, num_ous) -> (num_ous, ous)", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrGetJoinableOus_r, (py_data_pack_fn)pack_py_wkssvc_NetrGetJoinableOus_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrGetJoinableOus_args_out, 21, &ndr_table_wkssvc },
	{ "NetrJoinDomain2", "S.NetrJoinDomain2(server_name, domain_name, account_ou, admin_account, encrypted_password, join_flags) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrJoinDomain2_r, (py_data_pack_fn)pack_py_wkssvc_NetrJoinDomain2_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrJoinDomain2_args_out, 22, &ndr_table_wkssvc },
	{ "NetrUnjoinDomain2", "S.NetrUnjoinDomain2(server_name, account, encrypted_password, unjoin_flags) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrUnjoinDomain2_r, (py_data_pack_fn)pack_py_wkssvc_NetrUnjoinDomain2_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrUnjoinDomain2_args_out, 23, &ndr_table_wkssvc },
	{ "NetrRenameMachineInDomain2", "S.NetrRenameMachineInDomain2(server_name, NewMachineName, Account, EncryptedPassword, RenameOptions) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrRenameMachineInDomain2_r, (py_data_pack_fn)pack_py_wkssvc_NetrRenameMachineInDomain2_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrRenameMachineInDomain2_args_out, 24, &ndr_table_wkssvc },
	{ "NetrValidateName2", "S.NetrValidateName2(server_name, name, Account, EncryptedPassword, name_type) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrValidateName2_r, (py_data_pack_fn)pack_py_wkssvc_NetrValidateName2_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrValidateName2_args_out, 25, &ndr_table_wkssvc },
	{ "NetrGetJoinableOus2", "S.NetrGetJoinableOus2(server_name, domain_name, Account, EncryptedPassword, num_ous) -> (num_ous, ous)", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrGetJoinableOus2_r, (py_data_pack_fn)pack_py_wkssvc_NetrGetJoinableOus2_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrGetJoinableOus2_args_out, 26, &ndr_table_wkssvc },
	{ "NetrAddAlternateComputerName", "S.NetrAddAlternateComputerName(server_name, NewAlternateMachineName, Account, EncryptedPassword, Reserved) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrAddAlternateComputerName_r, (py_data_pack_fn)pack_py_wkssvc_NetrAddAlternateComputerName_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrAddAlternateComputerName_args_out, 27, &ndr_table_wkssvc },
	{ "NetrRemoveAlternateComputerName", "S.NetrRemoveAlternateComputerName(server_name, AlternateMachineNameToRemove, Account, EncryptedPassword, Reserved) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrRemoveAlternateComputerName_r, (py_data_pack_fn)pack_py_wkssvc_NetrRemoveAlternateComputerName_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrRemoveAlternateComputerName_args_out, 28, &ndr_table_wkssvc },
	{ "NetrSetPrimaryComputername", "S.NetrSetPrimaryComputername(server_name, primary_name, Account, EncryptedPassword, Reserved) -> None", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrSetPrimaryComputername_r, (py_data_pack_fn)pack_py_wkssvc_NetrSetPrimaryComputername_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrSetPrimaryComputername_args_out, 29, &ndr_table_wkssvc },
	{ "NetrEnumerateComputerNames", "S.NetrEnumerateComputerNames(server_name, name_type, Reserved) -> ctr", (py_dcerpc_call_fn)dcerpc_wkssvc_NetrEnumerateComputerNames_r, (py_data_pack_fn)pack_py_wkssvc_NetrEnumerateComputerNames_args_in, (py_data_unpack_fn)unpack_py_wkssvc_NetrEnumerateComputerNames_args_out, 30, &ndr_table_wkssvc },
	{ NULL }
};

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

#define PY_DOC_WKSSVC "Workstation Service"
static PyTypeObject wkssvc_InterfaceType = {
	PyObject_HEAD_INIT(NULL) 0,
	.tp_name = "wkssvc.wkssvc",
	.tp_basicsize = sizeof(dcerpc_InterfaceObject),
	.tp_doc = "wkssvc(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_WKSSVC,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = interface_wkssvc_new,
};

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

void initwkssvc(void)
{
	PyObject *m;
	PyObject *dep_talloc;
	PyObject *dep_samba_dcerpc_base;
	PyObject *dep_samba_dcerpc_srvsvc;
	PyObject *dep_samba_dcerpc_lsa;

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

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

	dep_samba_dcerpc_srvsvc = PyImport_ImportModule("samba.dcerpc.srvsvc");
	if (dep_samba_dcerpc_srvsvc == NULL)
		return;

	dep_samba_dcerpc_lsa = PyImport_ImportModule("samba.dcerpc.lsa");
	if (dep_samba_dcerpc_lsa == NULL)
		return;

	lsa_String_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_lsa, "String");
	if (lsa_String_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;

	wkssvc_NetWkstaInfo100_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo101_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo102_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo502_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1010_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1011_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1012_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1013_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1018_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1023_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1027_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1028_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1032_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1033_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1041_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1042_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1043_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1044_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1045_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1046_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1047_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1048_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1049_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1050_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1051_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1052_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1053_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1054_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1055_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1056_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1057_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1058_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1059_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1060_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1061_Type.tp_base = Object_Type;

	wkssvc_NetWkstaInfo1062_Type.tp_base = Object_Type;

	wkssvc_NetrWkstaUserInfo0_Type.tp_base = Object_Type;

	wkssvc_NetWkstaEnumUsersCtr0_Type.tp_base = Object_Type;

	wkssvc_NetrWkstaUserInfo1_Type.tp_base = Object_Type;

	wkssvc_NetWkstaEnumUsersCtr1_Type.tp_base = Object_Type;

	wkssvc_NetWkstaEnumUsersInfo_Type.tp_base = Object_Type;

	wkssvc_NetrWkstaUserInfo1101_Type.tp_base = Object_Type;

	wkssvc_NetWkstaTransportInfo0_Type.tp_base = Object_Type;

	wkssvc_NetWkstaTransportCtr0_Type.tp_base = Object_Type;

	wkssvc_NetWkstaTransportInfo_Type.tp_base = Object_Type;

	wkssvc_NetrUseInfo3_Type.tp_base = Object_Type;

	wkssvc_NetrUseInfo2_Type.tp_base = Object_Type;

	wkssvc_NetrUseInfo1_Type.tp_base = Object_Type;

	wkssvc_NetrUseInfo0_Type.tp_base = Object_Type;

	wkssvc_NetrUseEnumCtr2_Type.tp_base = Object_Type;

	wkssvc_NetrUseEnumCtr1_Type.tp_base = Object_Type;

	wkssvc_NetrUseEnumCtr0_Type.tp_base = Object_Type;

	wkssvc_NetrUseEnumInfo_Type.tp_base = Object_Type;

	wkssvc_NetrWorkstationStatistics_Type.tp_base = Object_Type;

	wkssvc_PasswordBuffer_Type.tp_base = Object_Type;

	wkssvc_ComputerNamesCtr_Type.tp_base = Object_Type;

	wkssvc_InterfaceType.tp_base = ClientConnection_Type;

	if (PyType_Ready(&wkssvc_NetWkstaInfo100_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo101_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo102_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo502_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1010_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1011_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1012_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1013_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1018_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1023_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1027_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1028_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1032_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1033_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1041_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1042_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1043_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1044_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1045_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1046_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1047_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1048_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1049_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1050_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1051_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1052_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1053_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1054_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1055_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1056_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1057_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1058_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1059_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1060_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1061_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaInfo1062_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrWkstaUserInfo0_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaEnumUsersCtr0_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrWkstaUserInfo1_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaEnumUsersCtr1_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaEnumUsersInfo_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrWkstaUserInfo1101_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaTransportInfo0_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaTransportCtr0_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetWkstaTransportInfo_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseInfo3_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseInfo2_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseInfo1_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseInfo0_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseEnumCtr2_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseEnumCtr1_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseEnumCtr0_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrUseEnumInfo_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_NetrWorkstationStatistics_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_PasswordBuffer_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_ComputerNamesCtr_Type) < 0)
		return;
	if (PyType_Ready(&wkssvc_InterfaceType) < 0)
		return;
	if (!PyInterface_AddNdrRpcMethods(&wkssvc_InterfaceType, py_ndr_wkssvc_methods))
		return;

#ifdef PY_NETWKSTAINFO100_PATCH
	PY_NETWKSTAINFO100_PATCH(&wkssvc_NetWkstaInfo100_Type);
#endif
#ifdef PY_NETWKSTAINFO101_PATCH
	PY_NETWKSTAINFO101_PATCH(&wkssvc_NetWkstaInfo101_Type);
#endif
#ifdef PY_NETWKSTAINFO102_PATCH
	PY_NETWKSTAINFO102_PATCH(&wkssvc_NetWkstaInfo102_Type);
#endif
#ifdef PY_NETWKSTAINFO502_PATCH
	PY_NETWKSTAINFO502_PATCH(&wkssvc_NetWkstaInfo502_Type);
#endif
#ifdef PY_NETWKSTAINFO1010_PATCH
	PY_NETWKSTAINFO1010_PATCH(&wkssvc_NetWkstaInfo1010_Type);
#endif
#ifdef PY_NETWKSTAINFO1011_PATCH
	PY_NETWKSTAINFO1011_PATCH(&wkssvc_NetWkstaInfo1011_Type);
#endif
#ifdef PY_NETWKSTAINFO1012_PATCH
	PY_NETWKSTAINFO1012_PATCH(&wkssvc_NetWkstaInfo1012_Type);
#endif
#ifdef PY_NETWKSTAINFO1013_PATCH
	PY_NETWKSTAINFO1013_PATCH(&wkssvc_NetWkstaInfo1013_Type);
#endif
#ifdef PY_NETWKSTAINFO1018_PATCH
	PY_NETWKSTAINFO1018_PATCH(&wkssvc_NetWkstaInfo1018_Type);
#endif
#ifdef PY_NETWKSTAINFO1023_PATCH
	PY_NETWKSTAINFO1023_PATCH(&wkssvc_NetWkstaInfo1023_Type);
#endif
#ifdef PY_NETWKSTAINFO1027_PATCH
	PY_NETWKSTAINFO1027_PATCH(&wkssvc_NetWkstaInfo1027_Type);
#endif
#ifdef PY_NETWKSTAINFO1028_PATCH
	PY_NETWKSTAINFO1028_PATCH(&wkssvc_NetWkstaInfo1028_Type);
#endif
#ifdef PY_NETWKSTAINFO1032_PATCH
	PY_NETWKSTAINFO1032_PATCH(&wkssvc_NetWkstaInfo1032_Type);
#endif
#ifdef PY_NETWKSTAINFO1033_PATCH
	PY_NETWKSTAINFO1033_PATCH(&wkssvc_NetWkstaInfo1033_Type);
#endif
#ifdef PY_NETWKSTAINFO1041_PATCH
	PY_NETWKSTAINFO1041_PATCH(&wkssvc_NetWkstaInfo1041_Type);
#endif
#ifdef PY_NETWKSTAINFO1042_PATCH
	PY_NETWKSTAINFO1042_PATCH(&wkssvc_NetWkstaInfo1042_Type);
#endif
#ifdef PY_NETWKSTAINFO1043_PATCH
	PY_NETWKSTAINFO1043_PATCH(&wkssvc_NetWkstaInfo1043_Type);
#endif
#ifdef PY_NETWKSTAINFO1044_PATCH
	PY_NETWKSTAINFO1044_PATCH(&wkssvc_NetWkstaInfo1044_Type);
#endif
#ifdef PY_NETWKSTAINFO1045_PATCH
	PY_NETWKSTAINFO1045_PATCH(&wkssvc_NetWkstaInfo1045_Type);
#endif
#ifdef PY_NETWKSTAINFO1046_PATCH
	PY_NETWKSTAINFO1046_PATCH(&wkssvc_NetWkstaInfo1046_Type);
#endif
#ifdef PY_NETWKSTAINFO1047_PATCH
	PY_NETWKSTAINFO1047_PATCH(&wkssvc_NetWkstaInfo1047_Type);
#endif
#ifdef PY_NETWKSTAINFO1048_PATCH
	PY_NETWKSTAINFO1048_PATCH(&wkssvc_NetWkstaInfo1048_Type);
#endif
#ifdef PY_NETWKSTAINFO1049_PATCH
	PY_NETWKSTAINFO1049_PATCH(&wkssvc_NetWkstaInfo1049_Type);
#endif
#ifdef PY_NETWKSTAINFO1050_PATCH
	PY_NETWKSTAINFO1050_PATCH(&wkssvc_NetWkstaInfo1050_Type);
#endif
#ifdef PY_NETWKSTAINFO1051_PATCH
	PY_NETWKSTAINFO1051_PATCH(&wkssvc_NetWkstaInfo1051_Type);
#endif
#ifdef PY_NETWKSTAINFO1052_PATCH
	PY_NETWKSTAINFO1052_PATCH(&wkssvc_NetWkstaInfo1052_Type);
#endif
#ifdef PY_NETWKSTAINFO1053_PATCH
	PY_NETWKSTAINFO1053_PATCH(&wkssvc_NetWkstaInfo1053_Type);
#endif
#ifdef PY_NETWKSTAINFO1054_PATCH
	PY_NETWKSTAINFO1054_PATCH(&wkssvc_NetWkstaInfo1054_Type);
#endif
#ifdef PY_NETWKSTAINFO1055_PATCH
	PY_NETWKSTAINFO1055_PATCH(&wkssvc_NetWkstaInfo1055_Type);
#endif
#ifdef PY_NETWKSTAINFO1056_PATCH
	PY_NETWKSTAINFO1056_PATCH(&wkssvc_NetWkstaInfo1056_Type);
#endif
#ifdef PY_NETWKSTAINFO1057_PATCH
	PY_NETWKSTAINFO1057_PATCH(&wkssvc_NetWkstaInfo1057_Type);
#endif
#ifdef PY_NETWKSTAINFO1058_PATCH
	PY_NETWKSTAINFO1058_PATCH(&wkssvc_NetWkstaInfo1058_Type);
#endif
#ifdef PY_NETWKSTAINFO1059_PATCH
	PY_NETWKSTAINFO1059_PATCH(&wkssvc_NetWkstaInfo1059_Type);
#endif
#ifdef PY_NETWKSTAINFO1060_PATCH
	PY_NETWKSTAINFO1060_PATCH(&wkssvc_NetWkstaInfo1060_Type);
#endif
#ifdef PY_NETWKSTAINFO1061_PATCH
	PY_NETWKSTAINFO1061_PATCH(&wkssvc_NetWkstaInfo1061_Type);
#endif
#ifdef PY_NETWKSTAINFO1062_PATCH
	PY_NETWKSTAINFO1062_PATCH(&wkssvc_NetWkstaInfo1062_Type);
#endif
#ifdef PY_NETRWKSTAUSERINFO0_PATCH
	PY_NETRWKSTAUSERINFO0_PATCH(&wkssvc_NetrWkstaUserInfo0_Type);
#endif
#ifdef PY_NETWKSTAENUMUSERSCTR0_PATCH
	PY_NETWKSTAENUMUSERSCTR0_PATCH(&wkssvc_NetWkstaEnumUsersCtr0_Type);
#endif
#ifdef PY_NETRWKSTAUSERINFO1_PATCH
	PY_NETRWKSTAUSERINFO1_PATCH(&wkssvc_NetrWkstaUserInfo1_Type);
#endif
#ifdef PY_NETWKSTAENUMUSERSCTR1_PATCH
	PY_NETWKSTAENUMUSERSCTR1_PATCH(&wkssvc_NetWkstaEnumUsersCtr1_Type);
#endif
#ifdef PY_NETWKSTAENUMUSERSINFO_PATCH
	PY_NETWKSTAENUMUSERSINFO_PATCH(&wkssvc_NetWkstaEnumUsersInfo_Type);
#endif
#ifdef PY_NETRWKSTAUSERINFO1101_PATCH
	PY_NETRWKSTAUSERINFO1101_PATCH(&wkssvc_NetrWkstaUserInfo1101_Type);
#endif
#ifdef PY_NETWKSTATRANSPORTINFO0_PATCH
	PY_NETWKSTATRANSPORTINFO0_PATCH(&wkssvc_NetWkstaTransportInfo0_Type);
#endif
#ifdef PY_NETWKSTATRANSPORTCTR0_PATCH
	PY_NETWKSTATRANSPORTCTR0_PATCH(&wkssvc_NetWkstaTransportCtr0_Type);
#endif
#ifdef PY_NETWKSTATRANSPORTINFO_PATCH
	PY_NETWKSTATRANSPORTINFO_PATCH(&wkssvc_NetWkstaTransportInfo_Type);
#endif
#ifdef PY_NETRUSEINFO3_PATCH
	PY_NETRUSEINFO3_PATCH(&wkssvc_NetrUseInfo3_Type);
#endif
#ifdef PY_NETRUSEINFO2_PATCH
	PY_NETRUSEINFO2_PATCH(&wkssvc_NetrUseInfo2_Type);
#endif
#ifdef PY_NETRUSEINFO1_PATCH
	PY_NETRUSEINFO1_PATCH(&wkssvc_NetrUseInfo1_Type);
#endif
#ifdef PY_NETRUSEINFO0_PATCH
	PY_NETRUSEINFO0_PATCH(&wkssvc_NetrUseInfo0_Type);
#endif
#ifdef PY_NETRUSEENUMCTR2_PATCH
	PY_NETRUSEENUMCTR2_PATCH(&wkssvc_NetrUseEnumCtr2_Type);
#endif
#ifdef PY_NETRUSEENUMCTR1_PATCH
	PY_NETRUSEENUMCTR1_PATCH(&wkssvc_NetrUseEnumCtr1_Type);
#endif
#ifdef PY_NETRUSEENUMCTR0_PATCH
	PY_NETRUSEENUMCTR0_PATCH(&wkssvc_NetrUseEnumCtr0_Type);
#endif
#ifdef PY_NETRUSEENUMINFO_PATCH
	PY_NETRUSEENUMINFO_PATCH(&wkssvc_NetrUseEnumInfo_Type);
#endif
#ifdef PY_NETRWORKSTATIONSTATISTICS_PATCH
	PY_NETRWORKSTATIONSTATISTICS_PATCH(&wkssvc_NetrWorkstationStatistics_Type);
#endif
#ifdef PY_PASSWORDBUFFER_PATCH
	PY_PASSWORDBUFFER_PATCH(&wkssvc_PasswordBuffer_Type);
#endif
#ifdef PY_COMPUTERNAMESCTR_PATCH
	PY_COMPUTERNAMESCTR_PATCH(&wkssvc_ComputerNamesCtr_Type);
#endif
#ifdef PY_WKSSVC_PATCH
	PY_WKSSVC_PATCH(&wkssvc_InterfaceType);
#endif

	m = Py_InitModule3("wkssvc", wkssvc_methods, "wkssvc DCE/RPC");
	if (m == NULL)
		return;

	PyModule_AddObject(m, "NetSetupUnknown", PyInt_FromLong(NetSetupUnknown));
	PyModule_AddObject(m, "NetPrimaryComputerName", PyInt_FromLong(NetPrimaryComputerName));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", PyInt_FromLong(WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", PyInt_FromLong(WKSSVC_JOIN_FLAGS_JOIN_UNSECURE));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", PyInt_FromLong(WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_JOIN_TYPE", PyInt_FromLong(WKSSVC_JOIN_FLAGS_JOIN_TYPE));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", PyInt_FromLong(WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", PyInt_FromLong(WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE));
	PyModule_AddObject(m, "NetSetupMachine", PyInt_FromLong(NetSetupMachine));
	PyModule_AddObject(m, "NET_SETUP_UNKNOWN_STATUS", PyInt_FromLong(NET_SETUP_UNKNOWN_STATUS));
	PyModule_AddObject(m, "NetAllComputerNames", PyInt_FromLong(NetAllComputerNames));
	PyModule_AddObject(m, "NetSetupDnsMachine", PyInt_FromLong(NetSetupDnsMachine));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", PyInt_FromLong(WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE));
	PyModule_AddObject(m, "NET_SETUP_UNJOINED", PyInt_FromLong(NET_SETUP_UNJOINED));
	PyModule_AddObject(m, "NET_SETUP_DOMAIN_NAME", PyInt_FromLong(NET_SETUP_DOMAIN_NAME));
	PyModule_AddObject(m, "NetComputerNameTypeMax", PyInt_FromLong(NetComputerNameTypeMax));
	PyModule_AddObject(m, "NetAlternateComputerNames", PyInt_FromLong(NetAlternateComputerNames));
	PyModule_AddObject(m, "NetSetupNonExistentDomain", PyInt_FromLong(NetSetupNonExistentDomain));
	PyModule_AddObject(m, "NET_SETUP_WORKGROUP_NAME", PyInt_FromLong(NET_SETUP_WORKGROUP_NAME));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS", PyInt_FromLong(WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS));
	PyModule_AddObject(m, "NetSetupDomain", PyInt_FromLong(NetSetupDomain));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_DEFER_SPN", PyInt_FromLong(WKSSVC_JOIN_FLAGS_DEFER_SPN));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", PyInt_FromLong(WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED));
	PyModule_AddObject(m, "NetSetupWorkgroup", PyInt_FromLong(NetSetupWorkgroup));
	PyModule_AddObject(m, "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", PyInt_FromLong(WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT));
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo100_Type);
	PyModule_AddObject(m, "NetWkstaInfo100", (PyObject *)(void *)&wkssvc_NetWkstaInfo100_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo101_Type);
	PyModule_AddObject(m, "NetWkstaInfo101", (PyObject *)(void *)&wkssvc_NetWkstaInfo101_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo102_Type);
	PyModule_AddObject(m, "NetWkstaInfo102", (PyObject *)(void *)&wkssvc_NetWkstaInfo102_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo502_Type);
	PyModule_AddObject(m, "NetWkstaInfo502", (PyObject *)(void *)&wkssvc_NetWkstaInfo502_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1010_Type);
	PyModule_AddObject(m, "NetWkstaInfo1010", (PyObject *)(void *)&wkssvc_NetWkstaInfo1010_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1011_Type);
	PyModule_AddObject(m, "NetWkstaInfo1011", (PyObject *)(void *)&wkssvc_NetWkstaInfo1011_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1012_Type);
	PyModule_AddObject(m, "NetWkstaInfo1012", (PyObject *)(void *)&wkssvc_NetWkstaInfo1012_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1013_Type);
	PyModule_AddObject(m, "NetWkstaInfo1013", (PyObject *)(void *)&wkssvc_NetWkstaInfo1013_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1018_Type);
	PyModule_AddObject(m, "NetWkstaInfo1018", (PyObject *)(void *)&wkssvc_NetWkstaInfo1018_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1023_Type);
	PyModule_AddObject(m, "NetWkstaInfo1023", (PyObject *)(void *)&wkssvc_NetWkstaInfo1023_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1027_Type);
	PyModule_AddObject(m, "NetWkstaInfo1027", (PyObject *)(void *)&wkssvc_NetWkstaInfo1027_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1028_Type);
	PyModule_AddObject(m, "NetWkstaInfo1028", (PyObject *)(void *)&wkssvc_NetWkstaInfo1028_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1032_Type);
	PyModule_AddObject(m, "NetWkstaInfo1032", (PyObject *)(void *)&wkssvc_NetWkstaInfo1032_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1033_Type);
	PyModule_AddObject(m, "NetWkstaInfo1033", (PyObject *)(void *)&wkssvc_NetWkstaInfo1033_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1041_Type);
	PyModule_AddObject(m, "NetWkstaInfo1041", (PyObject *)(void *)&wkssvc_NetWkstaInfo1041_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1042_Type);
	PyModule_AddObject(m, "NetWkstaInfo1042", (PyObject *)(void *)&wkssvc_NetWkstaInfo1042_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1043_Type);
	PyModule_AddObject(m, "NetWkstaInfo1043", (PyObject *)(void *)&wkssvc_NetWkstaInfo1043_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1044_Type);
	PyModule_AddObject(m, "NetWkstaInfo1044", (PyObject *)(void *)&wkssvc_NetWkstaInfo1044_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1045_Type);
	PyModule_AddObject(m, "NetWkstaInfo1045", (PyObject *)(void *)&wkssvc_NetWkstaInfo1045_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1046_Type);
	PyModule_AddObject(m, "NetWkstaInfo1046", (PyObject *)(void *)&wkssvc_NetWkstaInfo1046_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1047_Type);
	PyModule_AddObject(m, "NetWkstaInfo1047", (PyObject *)(void *)&wkssvc_NetWkstaInfo1047_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1048_Type);
	PyModule_AddObject(m, "NetWkstaInfo1048", (PyObject *)(void *)&wkssvc_NetWkstaInfo1048_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1049_Type);
	PyModule_AddObject(m, "NetWkstaInfo1049", (PyObject *)(void *)&wkssvc_NetWkstaInfo1049_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1050_Type);
	PyModule_AddObject(m, "NetWkstaInfo1050", (PyObject *)(void *)&wkssvc_NetWkstaInfo1050_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1051_Type);
	PyModule_AddObject(m, "NetWkstaInfo1051", (PyObject *)(void *)&wkssvc_NetWkstaInfo1051_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1052_Type);
	PyModule_AddObject(m, "NetWkstaInfo1052", (PyObject *)(void *)&wkssvc_NetWkstaInfo1052_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1053_Type);
	PyModule_AddObject(m, "NetWkstaInfo1053", (PyObject *)(void *)&wkssvc_NetWkstaInfo1053_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1054_Type);
	PyModule_AddObject(m, "NetWkstaInfo1054", (PyObject *)(void *)&wkssvc_NetWkstaInfo1054_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1055_Type);
	PyModule_AddObject(m, "NetWkstaInfo1055", (PyObject *)(void *)&wkssvc_NetWkstaInfo1055_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1056_Type);
	PyModule_AddObject(m, "NetWkstaInfo1056", (PyObject *)(void *)&wkssvc_NetWkstaInfo1056_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1057_Type);
	PyModule_AddObject(m, "NetWkstaInfo1057", (PyObject *)(void *)&wkssvc_NetWkstaInfo1057_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1058_Type);
	PyModule_AddObject(m, "NetWkstaInfo1058", (PyObject *)(void *)&wkssvc_NetWkstaInfo1058_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1059_Type);
	PyModule_AddObject(m, "NetWkstaInfo1059", (PyObject *)(void *)&wkssvc_NetWkstaInfo1059_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1060_Type);
	PyModule_AddObject(m, "NetWkstaInfo1060", (PyObject *)(void *)&wkssvc_NetWkstaInfo1060_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1061_Type);
	PyModule_AddObject(m, "NetWkstaInfo1061", (PyObject *)(void *)&wkssvc_NetWkstaInfo1061_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaInfo1062_Type);
	PyModule_AddObject(m, "NetWkstaInfo1062", (PyObject *)(void *)&wkssvc_NetWkstaInfo1062_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrWkstaUserInfo0_Type);
	PyModule_AddObject(m, "NetrWkstaUserInfo0", (PyObject *)(void *)&wkssvc_NetrWkstaUserInfo0_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaEnumUsersCtr0_Type);
	PyModule_AddObject(m, "NetWkstaEnumUsersCtr0", (PyObject *)(void *)&wkssvc_NetWkstaEnumUsersCtr0_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrWkstaUserInfo1_Type);
	PyModule_AddObject(m, "NetrWkstaUserInfo1", (PyObject *)(void *)&wkssvc_NetrWkstaUserInfo1_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaEnumUsersCtr1_Type);
	PyModule_AddObject(m, "NetWkstaEnumUsersCtr1", (PyObject *)(void *)&wkssvc_NetWkstaEnumUsersCtr1_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaEnumUsersInfo_Type);
	PyModule_AddObject(m, "NetWkstaEnumUsersInfo", (PyObject *)(void *)&wkssvc_NetWkstaEnumUsersInfo_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrWkstaUserInfo1101_Type);
	PyModule_AddObject(m, "NetrWkstaUserInfo1101", (PyObject *)(void *)&wkssvc_NetrWkstaUserInfo1101_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaTransportInfo0_Type);
	PyModule_AddObject(m, "NetWkstaTransportInfo0", (PyObject *)(void *)&wkssvc_NetWkstaTransportInfo0_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaTransportCtr0_Type);
	PyModule_AddObject(m, "NetWkstaTransportCtr0", (PyObject *)(void *)&wkssvc_NetWkstaTransportCtr0_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetWkstaTransportInfo_Type);
	PyModule_AddObject(m, "NetWkstaTransportInfo", (PyObject *)(void *)&wkssvc_NetWkstaTransportInfo_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseInfo3_Type);
	PyModule_AddObject(m, "NetrUseInfo3", (PyObject *)(void *)&wkssvc_NetrUseInfo3_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseInfo2_Type);
	PyModule_AddObject(m, "NetrUseInfo2", (PyObject *)(void *)&wkssvc_NetrUseInfo2_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseInfo1_Type);
	PyModule_AddObject(m, "NetrUseInfo1", (PyObject *)(void *)&wkssvc_NetrUseInfo1_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseInfo0_Type);
	PyModule_AddObject(m, "NetrUseInfo0", (PyObject *)(void *)&wkssvc_NetrUseInfo0_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseEnumCtr2_Type);
	PyModule_AddObject(m, "NetrUseEnumCtr2", (PyObject *)(void *)&wkssvc_NetrUseEnumCtr2_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseEnumCtr1_Type);
	PyModule_AddObject(m, "NetrUseEnumCtr1", (PyObject *)(void *)&wkssvc_NetrUseEnumCtr1_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseEnumCtr0_Type);
	PyModule_AddObject(m, "NetrUseEnumCtr0", (PyObject *)(void *)&wkssvc_NetrUseEnumCtr0_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrUseEnumInfo_Type);
	PyModule_AddObject(m, "NetrUseEnumInfo", (PyObject *)(void *)&wkssvc_NetrUseEnumInfo_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_NetrWorkstationStatistics_Type);
	PyModule_AddObject(m, "NetrWorkstationStatistics", (PyObject *)(void *)&wkssvc_NetrWorkstationStatistics_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_PasswordBuffer_Type);
	PyModule_AddObject(m, "PasswordBuffer", (PyObject *)(void *)&wkssvc_PasswordBuffer_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_ComputerNamesCtr_Type);
	PyModule_AddObject(m, "ComputerNamesCtr", (PyObject *)(void *)&wkssvc_ComputerNamesCtr_Type);
	Py_INCREF((PyObject *)(void *)&wkssvc_InterfaceType);
	PyModule_AddObject(m, "wkssvc", (PyObject *)(void *)&wkssvc_InterfaceType);
#ifdef PY_MOD_WKSSVC_PATCH
	PY_MOD_WKSSVC_PATCH(m);
#endif

}
