/* Python wrapper functions auto-generated by pidl */
#define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
#include <Python.h>
#include "python/py3compat.h"
#include "includes.h"
#include "python/modules.h"
#include <pytalloc.h>
#include "librpc/rpc/pyrpc.h"
#include "librpc/rpc/pyrpc_util.h"
#include "bin/default/librpc/gen_ndr/ndr_backupkey.h"
#include "bin/default/librpc/gen_ndr/ndr_backupkey_c.h"

/*
 * Suppress compiler warnings if the generated code does not call these
 * functions
 */
#ifndef _MAYBE_UNUSED_
#ifdef __has_attribute
#if __has_attribute(unused)
#define _MAYBE_UNUSED_ __attribute__ ((unused))
#else
#define _MAYBE_UNUSED_
#endif
#endif
#endif
/*
 * These functions are here to ensure they can be optimized out by
 * the compiler based on the constant input values
 */

static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
{
	switch (var_size) {
	case 8:
		return UINT64_MAX;
	case 4:
		return UINT32_MAX;
	case 2:
		return UINT16_MAX;
	case 1:
		return UINT8_MAX;
	}

	return 0;
}

static inline _MAYBE_UNUSED_ long long ndr_sizeof2intmax(size_t var_size)
{
	switch (var_size) {
	case 8:
		return INT64_MAX;
	case 4:
		return INT32_MAX;
	case 2:
		return INT16_MAX;
	case 1:
		return INT8_MAX;
	}

	return 0;
}

#include "librpc/gen_ndr/misc.h"
#include "librpc/gen_ndr/security.h"
static PyTypeObject bkrp_exported_RSA_key_pair_Type;
static PyTypeObject bkrp_dc_serverwrap_key_Type;
static PyTypeObject bkrp_empty_Type;
static PyTypeObject bkrp_client_side_wrapped_Type;
static PyTypeObject bkrp_client_side_unwrapped_Type;
static PyTypeObject bkrp_encrypted_secret_v2_Type;
static PyTypeObject bkrp_encrypted_secret_v3_Type;
static PyTypeObject bkrp_access_check_v2_Type;
static PyTypeObject bkrp_access_check_v3_Type;
static PyTypeObject bkrp_rc4encryptedpayload_Type;
static PyTypeObject bkrp_server_side_wrapped_Type;
static PyTypeObject bkrp_opaque_blob_Type;
static PyTypeObject bkrp_data_in_blob_Type;
static PyTypeObject backupkey_InterfaceType;
static PyTypeObject bkrp_BackupKey_Type;

static PyTypeObject *BaseObject_Type;
static PyTypeObject *GUID_Type;
static PyTypeObject *dom_sid_Type;
static PyTypeObject *ClientConnection_Type;
static PyTypeObject *ndr_syntax_id_Type;

static PyObject *py_bkrp_exported_RSA_key_pair_get_header1(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_header1;
	py_header1 = PyLong_FromUnsignedLongLong((uint32_t)object->header1);
	return py_header1;
}

static int py_bkrp_exported_RSA_key_pair_set_header1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->header1");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->header1));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->header1 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_header2(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_header2;
	py_header2 = PyLong_FromUnsignedLongLong((uint32_t)object->header2);
	return py_header2;
}

static int py_bkrp_exported_RSA_key_pair_set_header2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->header2");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->header2));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->header2 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_certificate_len(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_certificate_len;
	py_certificate_len = PyLong_FromUnsignedLongLong((uint32_t)object->certificate_len);
	return py_certificate_len;
}

static int py_bkrp_exported_RSA_key_pair_set_certificate_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->certificate_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->certificate_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->certificate_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_magic1(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_magic1;
	py_magic1 = PyLong_FromUnsignedLongLong((uint32_t)object->magic1);
	return py_magic1;
}

static int py_bkrp_exported_RSA_key_pair_set_magic1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic1");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic1));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic1 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_magic2(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_magic2;
	py_magic2 = PyLong_FromUnsignedLongLong((uint32_t)object->magic2);
	return py_magic2;
}

static int py_bkrp_exported_RSA_key_pair_set_magic2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic2");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic2));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic2 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_magic3(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_magic3;
	py_magic3 = PyLong_FromUnsignedLongLong((uint32_t)object->magic3);
	return py_magic3;
}

static int py_bkrp_exported_RSA_key_pair_set_magic3(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic3");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic3));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic3 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_magic4(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_magic4;
	py_magic4 = PyLong_FromUnsignedLongLong((uint32_t)object->magic4);
	return py_magic4;
}

static int py_bkrp_exported_RSA_key_pair_set_magic4(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic4");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic4));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic4 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_public_exponent(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_public_exponent;
	py_public_exponent = PyBytes_FromStringAndSize((char *)(object->public_exponent).data, (object->public_exponent).length);
	return py_public_exponent;
}

static int py_bkrp_exported_RSA_key_pair_set_public_exponent(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->public_exponent");
		return -1;
	}
	object->public_exponent = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_modulus(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_modulus;
	py_modulus = PyBytes_FromStringAndSize((char *)(object->modulus).data, (object->modulus).length);
	return py_modulus;
}

static int py_bkrp_exported_RSA_key_pair_set_modulus(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->modulus");
		return -1;
	}
	object->modulus = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_prime1(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_prime1;
	py_prime1 = PyBytes_FromStringAndSize((char *)(object->prime1).data, (object->prime1).length);
	return py_prime1;
}

static int py_bkrp_exported_RSA_key_pair_set_prime1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->prime1");
		return -1;
	}
	object->prime1 = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_prime2(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_prime2;
	py_prime2 = PyBytes_FromStringAndSize((char *)(object->prime2).data, (object->prime2).length);
	return py_prime2;
}

static int py_bkrp_exported_RSA_key_pair_set_prime2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->prime2");
		return -1;
	}
	object->prime2 = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_exponent1(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_exponent1;
	py_exponent1 = PyBytes_FromStringAndSize((char *)(object->exponent1).data, (object->exponent1).length);
	return py_exponent1;
}

static int py_bkrp_exported_RSA_key_pair_set_exponent1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->exponent1");
		return -1;
	}
	object->exponent1 = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_exponent2(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_exponent2;
	py_exponent2 = PyBytes_FromStringAndSize((char *)(object->exponent2).data, (object->exponent2).length);
	return py_exponent2;
}

static int py_bkrp_exported_RSA_key_pair_set_exponent2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->exponent2");
		return -1;
	}
	object->exponent2 = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_coefficient(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_coefficient;
	py_coefficient = PyBytes_FromStringAndSize((char *)(object->coefficient).data, (object->coefficient).length);
	return py_coefficient;
}

static int py_bkrp_exported_RSA_key_pair_set_coefficient(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->coefficient");
		return -1;
	}
	object->coefficient = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_private_exponent(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_private_exponent;
	py_private_exponent = PyBytes_FromStringAndSize((char *)(object->private_exponent).data, (object->private_exponent).length);
	return py_private_exponent;
}

static int py_bkrp_exported_RSA_key_pair_set_private_exponent(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->private_exponent");
		return -1;
	}
	object->private_exponent = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_bkrp_exported_RSA_key_pair_get_cert(PyObject *obj, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(obj);
	PyObject *py_cert;
	py_cert = PyBytes_FromStringAndSize((char *)(object->cert).data, (object->cert).length);
	return py_cert;
}

static int py_bkrp_exported_RSA_key_pair_set_cert(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_exported_RSA_key_pair *object = (struct bkrp_exported_RSA_key_pair *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->cert");
		return -1;
	}
	object->cert = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyGetSetDef py_bkrp_exported_RSA_key_pair_getsetters[] = {
	{
		.name = discard_const_p(char, "header1"),
		.get = py_bkrp_exported_RSA_key_pair_get_header1,
		.set = py_bkrp_exported_RSA_key_pair_set_header1,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "header2"),
		.get = py_bkrp_exported_RSA_key_pair_get_header2,
		.set = py_bkrp_exported_RSA_key_pair_set_header2,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "certificate_len"),
		.get = py_bkrp_exported_RSA_key_pair_get_certificate_len,
		.set = py_bkrp_exported_RSA_key_pair_set_certificate_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic1"),
		.get = py_bkrp_exported_RSA_key_pair_get_magic1,
		.set = py_bkrp_exported_RSA_key_pair_set_magic1,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic2"),
		.get = py_bkrp_exported_RSA_key_pair_get_magic2,
		.set = py_bkrp_exported_RSA_key_pair_set_magic2,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic3"),
		.get = py_bkrp_exported_RSA_key_pair_get_magic3,
		.set = py_bkrp_exported_RSA_key_pair_set_magic3,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic4"),
		.get = py_bkrp_exported_RSA_key_pair_get_magic4,
		.set = py_bkrp_exported_RSA_key_pair_set_magic4,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "public_exponent"),
		.get = py_bkrp_exported_RSA_key_pair_get_public_exponent,
		.set = py_bkrp_exported_RSA_key_pair_set_public_exponent,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "modulus"),
		.get = py_bkrp_exported_RSA_key_pair_get_modulus,
		.set = py_bkrp_exported_RSA_key_pair_set_modulus,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "prime1"),
		.get = py_bkrp_exported_RSA_key_pair_get_prime1,
		.set = py_bkrp_exported_RSA_key_pair_set_prime1,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "prime2"),
		.get = py_bkrp_exported_RSA_key_pair_get_prime2,
		.set = py_bkrp_exported_RSA_key_pair_set_prime2,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "exponent1"),
		.get = py_bkrp_exported_RSA_key_pair_get_exponent1,
		.set = py_bkrp_exported_RSA_key_pair_set_exponent1,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "exponent2"),
		.get = py_bkrp_exported_RSA_key_pair_get_exponent2,
		.set = py_bkrp_exported_RSA_key_pair_set_exponent2,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "coefficient"),
		.get = py_bkrp_exported_RSA_key_pair_get_coefficient,
		.set = py_bkrp_exported_RSA_key_pair_set_coefficient,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "private_exponent"),
		.get = py_bkrp_exported_RSA_key_pair_get_private_exponent,
		.set = py_bkrp_exported_RSA_key_pair_set_private_exponent,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "cert"),
		.get = py_bkrp_exported_RSA_key_pair_get_cert,
		.set = py_bkrp_exported_RSA_key_pair_set_cert,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_exported_RSA_key_pair_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_exported_RSA_key_pair",
	.tp_getset = py_bkrp_exported_RSA_key_pair_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_exported_RSA_key_pair_new,
};


static PyObject *py_bkrp_dc_serverwrap_key_get_magic(PyObject *obj, void *closure)
{
	struct bkrp_dc_serverwrap_key *object = (struct bkrp_dc_serverwrap_key *)pytalloc_get_ptr(obj);
	PyObject *py_magic;
	py_magic = PyLong_FromUnsignedLongLong((uint32_t)object->magic);
	return py_magic;
}

static int py_bkrp_dc_serverwrap_key_set_magic(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_dc_serverwrap_key *object = (struct bkrp_dc_serverwrap_key *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_dc_serverwrap_key_get_key(PyObject *obj, void *closure)
{
	struct bkrp_dc_serverwrap_key *object = (struct bkrp_dc_serverwrap_key *)pytalloc_get_ptr(obj);
	PyObject *py_key;
	py_key = PyList_New(256);
	if (py_key == NULL) {
		return NULL;
	}
	{
		int key_cntr_0;
		for (key_cntr_0 = 0; key_cntr_0 < (256); key_cntr_0++) {
			PyObject *py_key_0;
			py_key_0 = PyLong_FromLong((uint16_t)object->key[key_cntr_0]);
			PyList_SetItem(py_key, key_cntr_0, py_key_0);
		}
	}
	return py_key;
}

static int py_bkrp_dc_serverwrap_key_set_key(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_dc_serverwrap_key *object = (struct bkrp_dc_serverwrap_key *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->key");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int key_cntr_0;
		if (ARRAY_SIZE(object->key) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->key),  PyList_GET_SIZE(value));
			return -1;
		}
		for (key_cntr_0 = 0; key_cntr_0 < PyList_GET_SIZE(value); key_cntr_0++) {
			if (PyList_GET_ITEM(value, key_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->key[key_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->key[key_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, key_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, key_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->key[key_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_dc_serverwrap_key_getsetters[] = {
	{
		.name = discard_const_p(char, "magic"),
		.get = py_bkrp_dc_serverwrap_key_get_magic,
		.set = py_bkrp_dc_serverwrap_key_set_magic,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "key"),
		.get = py_bkrp_dc_serverwrap_key_get_key,
		.set = py_bkrp_dc_serverwrap_key_set_key,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_dc_serverwrap_key_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_dc_serverwrap_key",
	.tp_getset = py_bkrp_dc_serverwrap_key_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_dc_serverwrap_key_new,
};


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


static PyTypeObject bkrp_empty_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_empty",
	.tp_getset = NULL,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_empty_new,
};


static PyObject *py_bkrp_client_side_wrapped_get_version(PyObject *obj, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_version;
	py_version = PyLong_FromUnsignedLongLong((uint32_t)object->version);
	return py_version;
}

static int py_bkrp_client_side_wrapped_set_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_client_side_wrapped_get_encrypted_secret_len(PyObject *obj, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_encrypted_secret_len;
	py_encrypted_secret_len = PyLong_FromUnsignedLongLong((uint32_t)object->encrypted_secret_len);
	return py_encrypted_secret_len;
}

static int py_bkrp_client_side_wrapped_set_encrypted_secret_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->encrypted_secret_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->encrypted_secret_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->encrypted_secret_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_client_side_wrapped_get_access_check_len(PyObject *obj, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_access_check_len;
	py_access_check_len = PyLong_FromUnsignedLongLong((uint32_t)object->access_check_len);
	return py_access_check_len;
}

static int py_bkrp_client_side_wrapped_set_access_check_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->access_check_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->access_check_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->access_check_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_client_side_wrapped_get_guid(PyObject *obj, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_guid;
	py_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->guid);
	return py_guid;
}

static int py_bkrp_client_side_wrapped_set_guid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->guid");
		return -1;
	}
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->guid = *(struct GUID *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_bkrp_client_side_wrapped_get_encrypted_secret(PyObject *obj, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_encrypted_secret;
	py_encrypted_secret = PyList_New(object->encrypted_secret_len);
	if (py_encrypted_secret == NULL) {
		return NULL;
	}
	{
		int encrypted_secret_cntr_0;
		for (encrypted_secret_cntr_0 = 0; encrypted_secret_cntr_0 < (object->encrypted_secret_len); encrypted_secret_cntr_0++) {
			PyObject *py_encrypted_secret_0;
			py_encrypted_secret_0 = PyLong_FromLong((uint16_t)object->encrypted_secret[encrypted_secret_cntr_0]);
			PyList_SetItem(py_encrypted_secret, encrypted_secret_cntr_0, py_encrypted_secret_0);
		}
	}
	return py_encrypted_secret;
}

static int py_bkrp_client_side_wrapped_set_encrypted_secret(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->encrypted_secret");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int encrypted_secret_cntr_0;
		object->encrypted_secret = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->encrypted_secret, PyList_GET_SIZE(value));
		if (!object->encrypted_secret) { return -1;; }
		talloc_set_name_const(object->encrypted_secret, "ARRAY: object->encrypted_secret");
		for (encrypted_secret_cntr_0 = 0; encrypted_secret_cntr_0 < PyList_GET_SIZE(value); encrypted_secret_cntr_0++) {
			if (PyList_GET_ITEM(value, encrypted_secret_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->encrypted_secret[encrypted_secret_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->encrypted_secret[encrypted_secret_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, encrypted_secret_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, encrypted_secret_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->encrypted_secret[encrypted_secret_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_client_side_wrapped_get_access_check(PyObject *obj, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_access_check;
	py_access_check = PyList_New(object->access_check_len);
	if (py_access_check == NULL) {
		return NULL;
	}
	{
		int access_check_cntr_0;
		for (access_check_cntr_0 = 0; access_check_cntr_0 < (object->access_check_len); access_check_cntr_0++) {
			PyObject *py_access_check_0;
			py_access_check_0 = PyLong_FromLong((uint16_t)object->access_check[access_check_cntr_0]);
			PyList_SetItem(py_access_check, access_check_cntr_0, py_access_check_0);
		}
	}
	return py_access_check;
}

static int py_bkrp_client_side_wrapped_set_access_check(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_wrapped *object = (struct bkrp_client_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->access_check");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int access_check_cntr_0;
		object->access_check = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->access_check, PyList_GET_SIZE(value));
		if (!object->access_check) { return -1;; }
		talloc_set_name_const(object->access_check, "ARRAY: object->access_check");
		for (access_check_cntr_0 = 0; access_check_cntr_0 < PyList_GET_SIZE(value); access_check_cntr_0++) {
			if (PyList_GET_ITEM(value, access_check_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->access_check[access_check_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->access_check[access_check_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, access_check_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, access_check_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->access_check[access_check_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_client_side_wrapped_getsetters[] = {
	{
		.name = discard_const_p(char, "version"),
		.get = py_bkrp_client_side_wrapped_get_version,
		.set = py_bkrp_client_side_wrapped_set_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "encrypted_secret_len"),
		.get = py_bkrp_client_side_wrapped_get_encrypted_secret_len,
		.set = py_bkrp_client_side_wrapped_set_encrypted_secret_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "access_check_len"),
		.get = py_bkrp_client_side_wrapped_get_access_check_len,
		.set = py_bkrp_client_side_wrapped_set_access_check_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "guid"),
		.get = py_bkrp_client_side_wrapped_get_guid,
		.set = py_bkrp_client_side_wrapped_set_guid,
		.doc = discard_const_p(char, "PIDL-generated element of base type GUID")
	},
	{
		.name = discard_const_p(char, "encrypted_secret"),
		.get = py_bkrp_client_side_wrapped_get_encrypted_secret,
		.set = py_bkrp_client_side_wrapped_set_encrypted_secret,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "access_check"),
		.get = py_bkrp_client_side_wrapped_get_access_check,
		.set = py_bkrp_client_side_wrapped_set_access_check,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_client_side_wrapped_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_client_side_wrapped",
	.tp_getset = py_bkrp_client_side_wrapped_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_client_side_wrapped_new,
};


static PyObject *py_bkrp_client_side_unwrapped_get_magic(PyObject *obj, void *closure)
{
	struct bkrp_client_side_unwrapped *object = (struct bkrp_client_side_unwrapped *)pytalloc_get_ptr(obj);
	PyObject *py_magic;
	py_magic = PyLong_FromUnsignedLongLong((uint32_t)object->magic);
	return py_magic;
}

static int py_bkrp_client_side_unwrapped_set_magic(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_unwrapped *object = (struct bkrp_client_side_unwrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_client_side_unwrapped_get_secret(PyObject *obj, void *closure)
{
	struct bkrp_client_side_unwrapped *object = (struct bkrp_client_side_unwrapped *)pytalloc_get_ptr(obj);
	PyObject *py_secret;
	py_secret = PyBytes_FromStringAndSize((char *)(object->secret).data, (object->secret).length);
	return py_secret;
}

static int py_bkrp_client_side_unwrapped_set_secret(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_client_side_unwrapped *object = (struct bkrp_client_side_unwrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret");
		return -1;
	}
	object->secret = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyGetSetDef py_bkrp_client_side_unwrapped_getsetters[] = {
	{
		.name = discard_const_p(char, "magic"),
		.get = py_bkrp_client_side_unwrapped_get_magic,
		.set = py_bkrp_client_side_unwrapped_set_magic,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "secret"),
		.get = py_bkrp_client_side_unwrapped_get_secret,
		.set = py_bkrp_client_side_unwrapped_set_secret,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_client_side_unwrapped_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_client_side_unwrapped",
	.tp_getset = py_bkrp_client_side_unwrapped_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_client_side_unwrapped_new,
};


static PyObject *py_bkrp_encrypted_secret_v2_get_secret_len(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_secret_len;
	py_secret_len = PyLong_FromUnsignedLongLong((uint32_t)object->secret_len);
	return py_secret_len;
}

static int py_bkrp_encrypted_secret_v2_set_secret_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->secret_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->secret_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v2_get_magic(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_magic;
	py_magic = PyLong_FromUnsignedLongLong((uint32_t)object->magic);
	return py_magic;
}

static int py_bkrp_encrypted_secret_v2_set_magic(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v2_get_secret(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_secret;
	py_secret = PyList_New(object->secret_len);
	if (py_secret == NULL) {
		return NULL;
	}
	{
		int secret_cntr_0;
		for (secret_cntr_0 = 0; secret_cntr_0 < (object->secret_len); secret_cntr_0++) {
			PyObject *py_secret_0;
			py_secret_0 = PyLong_FromLong((uint16_t)object->secret[secret_cntr_0]);
			PyList_SetItem(py_secret, secret_cntr_0, py_secret_0);
		}
	}
	return py_secret;
}

static int py_bkrp_encrypted_secret_v2_set_secret(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int secret_cntr_0;
		object->secret = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->secret, PyList_GET_SIZE(value));
		if (!object->secret) { return -1;; }
		talloc_set_name_const(object->secret, "ARRAY: object->secret");
		for (secret_cntr_0 = 0; secret_cntr_0 < PyList_GET_SIZE(value); secret_cntr_0++) {
			if (PyList_GET_ITEM(value, secret_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret[secret_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->secret[secret_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, secret_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, secret_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->secret[secret_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v2_get_payload_key(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_payload_key;
	py_payload_key = PyList_New(32);
	if (py_payload_key == NULL) {
		return NULL;
	}
	{
		int payload_key_cntr_0;
		for (payload_key_cntr_0 = 0; payload_key_cntr_0 < (32); payload_key_cntr_0++) {
			PyObject *py_payload_key_0;
			py_payload_key_0 = PyLong_FromLong((uint16_t)object->payload_key[payload_key_cntr_0]);
			PyList_SetItem(py_payload_key, payload_key_cntr_0, py_payload_key_0);
		}
	}
	return py_payload_key;
}

static int py_bkrp_encrypted_secret_v2_set_payload_key(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v2 *object = (struct bkrp_encrypted_secret_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->payload_key");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int payload_key_cntr_0;
		if (ARRAY_SIZE(object->payload_key) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->payload_key),  PyList_GET_SIZE(value));
			return -1;
		}
		for (payload_key_cntr_0 = 0; payload_key_cntr_0 < PyList_GET_SIZE(value); payload_key_cntr_0++) {
			if (PyList_GET_ITEM(value, payload_key_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->payload_key[payload_key_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->payload_key[payload_key_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, payload_key_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, payload_key_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->payload_key[payload_key_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_encrypted_secret_v2_getsetters[] = {
	{
		.name = discard_const_p(char, "secret_len"),
		.get = py_bkrp_encrypted_secret_v2_get_secret_len,
		.set = py_bkrp_encrypted_secret_v2_set_secret_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic"),
		.get = py_bkrp_encrypted_secret_v2_get_magic,
		.set = py_bkrp_encrypted_secret_v2_set_magic,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "secret"),
		.get = py_bkrp_encrypted_secret_v2_get_secret,
		.set = py_bkrp_encrypted_secret_v2_set_secret,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "payload_key"),
		.get = py_bkrp_encrypted_secret_v2_get_payload_key,
		.set = py_bkrp_encrypted_secret_v2_set_payload_key,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_encrypted_secret_v2_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_encrypted_secret_v2",
	.tp_getset = py_bkrp_encrypted_secret_v2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_encrypted_secret_v2_new,
};


static PyObject *py_bkrp_encrypted_secret_v3_get_secret_len(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_secret_len;
	py_secret_len = PyLong_FromUnsignedLongLong((uint32_t)object->secret_len);
	return py_secret_len;
}

static int py_bkrp_encrypted_secret_v3_set_secret_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->secret_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->secret_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v3_get_magic1(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_magic1;
	py_magic1 = PyLong_FromUnsignedLongLong((uint32_t)object->magic1);
	return py_magic1;
}

static int py_bkrp_encrypted_secret_v3_set_magic1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic1");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic1));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic1 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v3_get_magic2(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_magic2;
	py_magic2 = PyLong_FromUnsignedLongLong((uint32_t)object->magic2);
	return py_magic2;
}

static int py_bkrp_encrypted_secret_v3_set_magic2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic2");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic2));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic2 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v3_get_magic3(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_magic3;
	py_magic3 = PyLong_FromUnsignedLongLong((uint32_t)object->magic3);
	return py_magic3;
}

static int py_bkrp_encrypted_secret_v3_set_magic3(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic3");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic3));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic3 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v3_get_secret(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_secret;
	py_secret = PyList_New(object->secret_len);
	if (py_secret == NULL) {
		return NULL;
	}
	{
		int secret_cntr_0;
		for (secret_cntr_0 = 0; secret_cntr_0 < (object->secret_len); secret_cntr_0++) {
			PyObject *py_secret_0;
			py_secret_0 = PyLong_FromLong((uint16_t)object->secret[secret_cntr_0]);
			PyList_SetItem(py_secret, secret_cntr_0, py_secret_0);
		}
	}
	return py_secret;
}

static int py_bkrp_encrypted_secret_v3_set_secret(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int secret_cntr_0;
		object->secret = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->secret, PyList_GET_SIZE(value));
		if (!object->secret) { return -1;; }
		talloc_set_name_const(object->secret, "ARRAY: object->secret");
		for (secret_cntr_0 = 0; secret_cntr_0 < PyList_GET_SIZE(value); secret_cntr_0++) {
			if (PyList_GET_ITEM(value, secret_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret[secret_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->secret[secret_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, secret_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, secret_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->secret[secret_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_encrypted_secret_v3_get_payload_key(PyObject *obj, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_payload_key;
	py_payload_key = PyList_New(48);
	if (py_payload_key == NULL) {
		return NULL;
	}
	{
		int payload_key_cntr_0;
		for (payload_key_cntr_0 = 0; payload_key_cntr_0 < (48); payload_key_cntr_0++) {
			PyObject *py_payload_key_0;
			py_payload_key_0 = PyLong_FromLong((uint16_t)object->payload_key[payload_key_cntr_0]);
			PyList_SetItem(py_payload_key, payload_key_cntr_0, py_payload_key_0);
		}
	}
	return py_payload_key;
}

static int py_bkrp_encrypted_secret_v3_set_payload_key(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_encrypted_secret_v3 *object = (struct bkrp_encrypted_secret_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->payload_key");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int payload_key_cntr_0;
		if (ARRAY_SIZE(object->payload_key) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->payload_key),  PyList_GET_SIZE(value));
			return -1;
		}
		for (payload_key_cntr_0 = 0; payload_key_cntr_0 < PyList_GET_SIZE(value); payload_key_cntr_0++) {
			if (PyList_GET_ITEM(value, payload_key_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->payload_key[payload_key_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->payload_key[payload_key_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, payload_key_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, payload_key_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->payload_key[payload_key_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_encrypted_secret_v3_getsetters[] = {
	{
		.name = discard_const_p(char, "secret_len"),
		.get = py_bkrp_encrypted_secret_v3_get_secret_len,
		.set = py_bkrp_encrypted_secret_v3_set_secret_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic1"),
		.get = py_bkrp_encrypted_secret_v3_get_magic1,
		.set = py_bkrp_encrypted_secret_v3_set_magic1,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic2"),
		.get = py_bkrp_encrypted_secret_v3_get_magic2,
		.set = py_bkrp_encrypted_secret_v3_set_magic2,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "magic3"),
		.get = py_bkrp_encrypted_secret_v3_get_magic3,
		.set = py_bkrp_encrypted_secret_v3_set_magic3,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "secret"),
		.get = py_bkrp_encrypted_secret_v3_get_secret,
		.set = py_bkrp_encrypted_secret_v3_set_secret,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "payload_key"),
		.get = py_bkrp_encrypted_secret_v3_get_payload_key,
		.set = py_bkrp_encrypted_secret_v3_set_payload_key,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_encrypted_secret_v3_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_encrypted_secret_v3",
	.tp_getset = py_bkrp_encrypted_secret_v3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_encrypted_secret_v3_new,
};


static PyObject *py_bkrp_access_check_v2_get_magic(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_magic;
	py_magic = PyLong_FromUnsignedLongLong((uint32_t)object->magic);
	return py_magic;
}

static int py_bkrp_access_check_v2_set_magic(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_access_check_v2_get_nonce_len(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_nonce_len;
	py_nonce_len = PyLong_FromUnsignedLongLong((uint32_t)object->nonce_len);
	return py_nonce_len;
}

static int py_bkrp_access_check_v2_set_nonce_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nonce_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->nonce_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->nonce_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_access_check_v2_get_nonce(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_nonce;
	py_nonce = PyList_New(object->nonce_len);
	if (py_nonce == NULL) {
		return NULL;
	}
	{
		int nonce_cntr_0;
		for (nonce_cntr_0 = 0; nonce_cntr_0 < (object->nonce_len); nonce_cntr_0++) {
			PyObject *py_nonce_0;
			py_nonce_0 = PyLong_FromLong((uint16_t)object->nonce[nonce_cntr_0]);
			PyList_SetItem(py_nonce, nonce_cntr_0, py_nonce_0);
		}
	}
	return py_nonce;
}

static int py_bkrp_access_check_v2_set_nonce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nonce");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int nonce_cntr_0;
		object->nonce = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->nonce, PyList_GET_SIZE(value));
		if (!object->nonce) { return -1;; }
		talloc_set_name_const(object->nonce, "ARRAY: object->nonce");
		for (nonce_cntr_0 = 0; nonce_cntr_0 < PyList_GET_SIZE(value); nonce_cntr_0++) {
			if (PyList_GET_ITEM(value, nonce_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nonce[nonce_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->nonce[nonce_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, nonce_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, nonce_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->nonce[nonce_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_access_check_v2_get_sid(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_sid;
	py_sid = pytalloc_reference_ex(dom_sid_Type, pytalloc_get_mem_ctx(obj), &object->sid);
	return py_sid;
}

static int py_bkrp_access_check_v2_set_sid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid");
		return -1;
	}
	PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->sid = *(struct dom_sid *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_bkrp_access_check_v2_get_hash(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(obj);
	PyObject *py_hash;
	py_hash = PyList_New(20);
	if (py_hash == NULL) {
		return NULL;
	}
	{
		int hash_cntr_0;
		for (hash_cntr_0 = 0; hash_cntr_0 < (20); hash_cntr_0++) {
			PyObject *py_hash_0;
			py_hash_0 = PyLong_FromLong((uint16_t)object->hash[hash_cntr_0]);
			PyList_SetItem(py_hash, hash_cntr_0, py_hash_0);
		}
	}
	return py_hash;
}

static int py_bkrp_access_check_v2_set_hash(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v2 *object = (struct bkrp_access_check_v2 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->hash");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int hash_cntr_0;
		if (ARRAY_SIZE(object->hash) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->hash),  PyList_GET_SIZE(value));
			return -1;
		}
		for (hash_cntr_0 = 0; hash_cntr_0 < PyList_GET_SIZE(value); hash_cntr_0++) {
			if (PyList_GET_ITEM(value, hash_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->hash[hash_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->hash[hash_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, hash_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, hash_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->hash[hash_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_access_check_v2_getsetters[] = {
	{
		.name = discard_const_p(char, "magic"),
		.get = py_bkrp_access_check_v2_get_magic,
		.set = py_bkrp_access_check_v2_set_magic,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "nonce_len"),
		.get = py_bkrp_access_check_v2_get_nonce_len,
		.set = py_bkrp_access_check_v2_set_nonce_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "nonce"),
		.get = py_bkrp_access_check_v2_get_nonce,
		.set = py_bkrp_access_check_v2_set_nonce,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "sid"),
		.get = py_bkrp_access_check_v2_get_sid,
		.set = py_bkrp_access_check_v2_set_sid,
		.doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
	},
	{
		.name = discard_const_p(char, "hash"),
		.get = py_bkrp_access_check_v2_get_hash,
		.set = py_bkrp_access_check_v2_set_hash,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_access_check_v2_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_access_check_v2",
	.tp_getset = py_bkrp_access_check_v2_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_access_check_v2_new,
};


static PyObject *py_bkrp_access_check_v3_get_magic(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_magic;
	py_magic = PyLong_FromUnsignedLongLong((uint32_t)object->magic);
	return py_magic;
}

static int py_bkrp_access_check_v3_set_magic(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_access_check_v3_get_nonce_len(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_nonce_len;
	py_nonce_len = PyLong_FromUnsignedLongLong((uint32_t)object->nonce_len);
	return py_nonce_len;
}

static int py_bkrp_access_check_v3_set_nonce_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nonce_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->nonce_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->nonce_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_access_check_v3_get_nonce(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_nonce;
	py_nonce = PyList_New(object->nonce_len);
	if (py_nonce == NULL) {
		return NULL;
	}
	{
		int nonce_cntr_0;
		for (nonce_cntr_0 = 0; nonce_cntr_0 < (object->nonce_len); nonce_cntr_0++) {
			PyObject *py_nonce_0;
			py_nonce_0 = PyLong_FromLong((uint16_t)object->nonce[nonce_cntr_0]);
			PyList_SetItem(py_nonce, nonce_cntr_0, py_nonce_0);
		}
	}
	return py_nonce;
}

static int py_bkrp_access_check_v3_set_nonce(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nonce");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int nonce_cntr_0;
		object->nonce = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->nonce, PyList_GET_SIZE(value));
		if (!object->nonce) { return -1;; }
		talloc_set_name_const(object->nonce, "ARRAY: object->nonce");
		for (nonce_cntr_0 = 0; nonce_cntr_0 < PyList_GET_SIZE(value); nonce_cntr_0++) {
			if (PyList_GET_ITEM(value, nonce_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nonce[nonce_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->nonce[nonce_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, nonce_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, nonce_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->nonce[nonce_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_access_check_v3_get_sid(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_sid;
	py_sid = pytalloc_reference_ex(dom_sid_Type, pytalloc_get_mem_ctx(obj), &object->sid);
	return py_sid;
}

static int py_bkrp_access_check_v3_set_sid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid");
		return -1;
	}
	PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->sid = *(struct dom_sid *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_bkrp_access_check_v3_get_hash(PyObject *obj, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(obj);
	PyObject *py_hash;
	py_hash = PyList_New(64);
	if (py_hash == NULL) {
		return NULL;
	}
	{
		int hash_cntr_0;
		for (hash_cntr_0 = 0; hash_cntr_0 < (64); hash_cntr_0++) {
			PyObject *py_hash_0;
			py_hash_0 = PyLong_FromLong((uint16_t)object->hash[hash_cntr_0]);
			PyList_SetItem(py_hash, hash_cntr_0, py_hash_0);
		}
	}
	return py_hash;
}

static int py_bkrp_access_check_v3_set_hash(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_access_check_v3 *object = (struct bkrp_access_check_v3 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->hash");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int hash_cntr_0;
		if (ARRAY_SIZE(object->hash) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->hash),  PyList_GET_SIZE(value));
			return -1;
		}
		for (hash_cntr_0 = 0; hash_cntr_0 < PyList_GET_SIZE(value); hash_cntr_0++) {
			if (PyList_GET_ITEM(value, hash_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->hash[hash_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->hash[hash_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, hash_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, hash_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->hash[hash_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_access_check_v3_getsetters[] = {
	{
		.name = discard_const_p(char, "magic"),
		.get = py_bkrp_access_check_v3_get_magic,
		.set = py_bkrp_access_check_v3_set_magic,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "nonce_len"),
		.get = py_bkrp_access_check_v3_get_nonce_len,
		.set = py_bkrp_access_check_v3_set_nonce_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "nonce"),
		.get = py_bkrp_access_check_v3_get_nonce,
		.set = py_bkrp_access_check_v3_set_nonce,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "sid"),
		.get = py_bkrp_access_check_v3_get_sid,
		.set = py_bkrp_access_check_v3_set_sid,
		.doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
	},
	{
		.name = discard_const_p(char, "hash"),
		.get = py_bkrp_access_check_v3_get_hash,
		.set = py_bkrp_access_check_v3_set_hash,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_access_check_v3_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_access_check_v3",
	.tp_getset = py_bkrp_access_check_v3_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_access_check_v3_new,
};


static PyObject *py_bkrp_rc4encryptedpayload_get_r3(PyObject *obj, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(obj);
	PyObject *py_r3;
	py_r3 = PyList_New(32);
	if (py_r3 == NULL) {
		return NULL;
	}
	{
		int r3_cntr_0;
		for (r3_cntr_0 = 0; r3_cntr_0 < (32); r3_cntr_0++) {
			PyObject *py_r3_0;
			py_r3_0 = PyLong_FromLong((uint16_t)object->r3[r3_cntr_0]);
			PyList_SetItem(py_r3, r3_cntr_0, py_r3_0);
		}
	}
	return py_r3;
}

static int py_bkrp_rc4encryptedpayload_set_r3(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->r3");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int r3_cntr_0;
		if (ARRAY_SIZE(object->r3) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->r3),  PyList_GET_SIZE(value));
			return -1;
		}
		for (r3_cntr_0 = 0; r3_cntr_0 < PyList_GET_SIZE(value); r3_cntr_0++) {
			if (PyList_GET_ITEM(value, r3_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->r3[r3_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->r3[r3_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, r3_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, r3_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->r3[r3_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_rc4encryptedpayload_get_mac(PyObject *obj, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(obj);
	PyObject *py_mac;
	py_mac = PyList_New(20);
	if (py_mac == NULL) {
		return NULL;
	}
	{
		int mac_cntr_0;
		for (mac_cntr_0 = 0; mac_cntr_0 < (20); mac_cntr_0++) {
			PyObject *py_mac_0;
			py_mac_0 = PyLong_FromLong((uint16_t)object->mac[mac_cntr_0]);
			PyList_SetItem(py_mac, mac_cntr_0, py_mac_0);
		}
	}
	return py_mac;
}

static int py_bkrp_rc4encryptedpayload_set_mac(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->mac");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int mac_cntr_0;
		if (ARRAY_SIZE(object->mac) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->mac),  PyList_GET_SIZE(value));
			return -1;
		}
		for (mac_cntr_0 = 0; mac_cntr_0 < PyList_GET_SIZE(value); mac_cntr_0++) {
			if (PyList_GET_ITEM(value, mac_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->mac[mac_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->mac[mac_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, mac_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, mac_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->mac[mac_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_rc4encryptedpayload_get_sid(PyObject *obj, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(obj);
	PyObject *py_sid;
	py_sid = pytalloc_reference_ex(dom_sid_Type, pytalloc_get_mem_ctx(obj), &object->sid);
	return py_sid;
}

static int py_bkrp_rc4encryptedpayload_set_sid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid");
		return -1;
	}
	PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->sid = *(struct dom_sid *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_bkrp_rc4encryptedpayload_get_secret_data(PyObject *obj, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(obj);
	PyObject *py_secret_data;
	py_secret_data = PyBytes_FromStringAndSize((char *)(object->secret_data).data, (object->secret_data).length);
	return py_secret_data;
}

static int py_bkrp_rc4encryptedpayload_set_secret_data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_rc4encryptedpayload *object = (struct bkrp_rc4encryptedpayload *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->secret_data");
		return -1;
	}
	object->secret_data = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyGetSetDef py_bkrp_rc4encryptedpayload_getsetters[] = {
	{
		.name = discard_const_p(char, "r3"),
		.get = py_bkrp_rc4encryptedpayload_get_r3,
		.set = py_bkrp_rc4encryptedpayload_set_r3,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "mac"),
		.get = py_bkrp_rc4encryptedpayload_get_mac,
		.set = py_bkrp_rc4encryptedpayload_set_mac,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "sid"),
		.get = py_bkrp_rc4encryptedpayload_get_sid,
		.set = py_bkrp_rc4encryptedpayload_set_sid,
		.doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
	},
	{
		.name = discard_const_p(char, "secret_data"),
		.get = py_bkrp_rc4encryptedpayload_get_secret_data,
		.set = py_bkrp_rc4encryptedpayload_set_secret_data,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_rc4encryptedpayload_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_rc4encryptedpayload",
	.tp_getset = py_bkrp_rc4encryptedpayload_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_rc4encryptedpayload_new,
};


static PyObject *py_bkrp_server_side_wrapped_get_magic(PyObject *obj, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_magic;
	py_magic = PyLong_FromUnsignedLongLong((uint32_t)object->magic);
	return py_magic;
}

static int py_bkrp_server_side_wrapped_set_magic(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->magic");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->magic));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->magic = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_server_side_wrapped_get_payload_length(PyObject *obj, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_payload_length;
	py_payload_length = PyLong_FromUnsignedLongLong((uint32_t)object->payload_length);
	return py_payload_length;
}

static int py_bkrp_server_side_wrapped_set_payload_length(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->payload_length");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->payload_length));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->payload_length = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_server_side_wrapped_get_ciphertext_length(PyObject *obj, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_ciphertext_length;
	py_ciphertext_length = PyLong_FromUnsignedLongLong((uint32_t)object->ciphertext_length);
	return py_ciphertext_length;
}

static int py_bkrp_server_side_wrapped_set_ciphertext_length(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->ciphertext_length");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ciphertext_length));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->ciphertext_length = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_server_side_wrapped_get_guid(PyObject *obj, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_guid;
	py_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->guid);
	return py_guid;
}

static int py_bkrp_server_side_wrapped_set_guid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->guid");
		return -1;
	}
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->guid = *(struct GUID *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_bkrp_server_side_wrapped_get_r2(PyObject *obj, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_r2;
	py_r2 = PyList_New(68);
	if (py_r2 == NULL) {
		return NULL;
	}
	{
		int r2_cntr_0;
		for (r2_cntr_0 = 0; r2_cntr_0 < (68); r2_cntr_0++) {
			PyObject *py_r2_0;
			py_r2_0 = PyLong_FromLong((uint16_t)object->r2[r2_cntr_0]);
			PyList_SetItem(py_r2, r2_cntr_0, py_r2_0);
		}
	}
	return py_r2;
}

static int py_bkrp_server_side_wrapped_set_r2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->r2");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int r2_cntr_0;
		if (ARRAY_SIZE(object->r2) != PyList_GET_SIZE(value)) {
			PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->r2),  PyList_GET_SIZE(value));
			return -1;
		}
		for (r2_cntr_0 = 0; r2_cntr_0 < PyList_GET_SIZE(value); r2_cntr_0++) {
			if (PyList_GET_ITEM(value, r2_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->r2[r2_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->r2[r2_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, r2_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, r2_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->r2[r2_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_server_side_wrapped_get_rc4encryptedpayload(PyObject *obj, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(obj);
	PyObject *py_rc4encryptedpayload;
	py_rc4encryptedpayload = PyList_New(object->ciphertext_length);
	if (py_rc4encryptedpayload == NULL) {
		return NULL;
	}
	{
		int rc4encryptedpayload_cntr_0;
		for (rc4encryptedpayload_cntr_0 = 0; rc4encryptedpayload_cntr_0 < (object->ciphertext_length); rc4encryptedpayload_cntr_0++) {
			PyObject *py_rc4encryptedpayload_0;
			py_rc4encryptedpayload_0 = PyLong_FromLong((uint16_t)object->rc4encryptedpayload[rc4encryptedpayload_cntr_0]);
			PyList_SetItem(py_rc4encryptedpayload, rc4encryptedpayload_cntr_0, py_rc4encryptedpayload_0);
		}
	}
	return py_rc4encryptedpayload;
}

static int py_bkrp_server_side_wrapped_set_rc4encryptedpayload(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_server_side_wrapped *object = (struct bkrp_server_side_wrapped *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->rc4encryptedpayload");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int rc4encryptedpayload_cntr_0;
		object->rc4encryptedpayload = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->rc4encryptedpayload, PyList_GET_SIZE(value));
		if (!object->rc4encryptedpayload) { return -1;; }
		talloc_set_name_const(object->rc4encryptedpayload, "ARRAY: object->rc4encryptedpayload");
		for (rc4encryptedpayload_cntr_0 = 0; rc4encryptedpayload_cntr_0 < PyList_GET_SIZE(value); rc4encryptedpayload_cntr_0++) {
			if (PyList_GET_ITEM(value, rc4encryptedpayload_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->rc4encryptedpayload[rc4encryptedpayload_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->rc4encryptedpayload[rc4encryptedpayload_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, rc4encryptedpayload_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, rc4encryptedpayload_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->rc4encryptedpayload[rc4encryptedpayload_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyGetSetDef py_bkrp_server_side_wrapped_getsetters[] = {
	{
		.name = discard_const_p(char, "magic"),
		.get = py_bkrp_server_side_wrapped_get_magic,
		.set = py_bkrp_server_side_wrapped_set_magic,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "payload_length"),
		.get = py_bkrp_server_side_wrapped_get_payload_length,
		.set = py_bkrp_server_side_wrapped_set_payload_length,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "ciphertext_length"),
		.get = py_bkrp_server_side_wrapped_get_ciphertext_length,
		.set = py_bkrp_server_side_wrapped_set_ciphertext_length,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "guid"),
		.get = py_bkrp_server_side_wrapped_get_guid,
		.set = py_bkrp_server_side_wrapped_set_guid,
		.doc = discard_const_p(char, "PIDL-generated element of base type GUID")
	},
	{
		.name = discard_const_p(char, "r2"),
		.get = py_bkrp_server_side_wrapped_get_r2,
		.set = py_bkrp_server_side_wrapped_set_r2,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "rc4encryptedpayload"),
		.get = py_bkrp_server_side_wrapped_get_rc4encryptedpayload,
		.set = py_bkrp_server_side_wrapped_set_rc4encryptedpayload,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_server_side_wrapped_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_server_side_wrapped",
	.tp_getset = py_bkrp_server_side_wrapped_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_server_side_wrapped_new,
};


static PyObject *py_bkrp_opaque_blob_get_opaque(PyObject *obj, void *closure)
{
	struct bkrp_opaque_blob *object = (struct bkrp_opaque_blob *)pytalloc_get_ptr(obj);
	PyObject *py_opaque;
	py_opaque = PyBytes_FromStringAndSize((char *)(object->opaque).data, (object->opaque).length);
	return py_opaque;
}

static int py_bkrp_opaque_blob_set_opaque(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_opaque_blob *object = (struct bkrp_opaque_blob *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->opaque");
		return -1;
	}
	object->opaque = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyGetSetDef py_bkrp_opaque_blob_getsetters[] = {
	{
		.name = discard_const_p(char, "opaque"),
		.get = py_bkrp_opaque_blob_get_opaque,
		.set = py_bkrp_opaque_blob_set_opaque,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{ .name = NULL }
};

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


static PyTypeObject bkrp_opaque_blob_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_opaque_blob",
	.tp_getset = py_bkrp_opaque_blob_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_opaque_blob_new,
};

static PyObject *py_import_bkrp_data_in_blob(TALLOC_CTX *mem_ctx, int level, union bkrp_data_in_blob *in)
{
	PyObject *ret;

	switch (level) {
		case BACKUPKEY_RESTORE_GUID_INTEGER:
			ret = pytalloc_reference_ex(&bkrp_client_side_wrapped_Type, mem_ctx, &in->restore_req);
			return ret;

		case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER:
			ret = pytalloc_reference_ex(&bkrp_empty_Type, mem_ctx, &in->empty);
			return ret;

		case BACKUPKEY_RESTORE_GUID_WIN2K_INTEGER:
			ret = pytalloc_reference_ex(&bkrp_server_side_wrapped_Type, mem_ctx, &in->unsign_req);
			return ret;

		case BACKUPKEY_BACKUP_GUID_INTEGER:
			ret = pytalloc_reference_ex(&bkrp_opaque_blob_Type, mem_ctx, &in->sign_req);
			return ret;

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

static union bkrp_data_in_blob *py_export_bkrp_data_in_blob(TALLOC_CTX *mem_ctx, int level, PyObject *in)
{
	union bkrp_data_in_blob *ret = talloc_zero(mem_ctx, union bkrp_data_in_blob);
	switch (level) {
		case BACKUPKEY_RESTORE_GUID_INTEGER:
			if (in == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->restore_req");
				talloc_free(ret); return NULL;
			}
			PY_CHECK_TYPE(&bkrp_client_side_wrapped_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->restore_req = *(struct bkrp_client_side_wrapped *)pytalloc_get_ptr(in);
			break;

		case BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER:
			if (in == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->empty");
				talloc_free(ret); return NULL;
			}
			PY_CHECK_TYPE(&bkrp_empty_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->empty = *(struct bkrp_empty *)pytalloc_get_ptr(in);
			break;

		case BACKUPKEY_RESTORE_GUID_WIN2K_INTEGER:
			if (in == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->unsign_req");
				talloc_free(ret); return NULL;
			}
			PY_CHECK_TYPE(&bkrp_server_side_wrapped_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->unsign_req = *(struct bkrp_server_side_wrapped *)pytalloc_get_ptr(in);
			break;

		case BACKUPKEY_BACKUP_GUID_INTEGER:
			if (in == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->sign_req");
				talloc_free(ret); return NULL;
			}
			PY_CHECK_TYPE(&bkrp_opaque_blob_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->sign_req = *(struct bkrp_opaque_blob *)pytalloc_get_ptr(in);
			break;

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

	return ret;
}

static PyObject *py_bkrp_data_in_blob_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
	PyObject *mem_ctx_obj = NULL;
	TALLOC_CTX *mem_ctx = NULL;
	int level = 0;
	PyObject *in_obj = NULL;
	union bkrp_data_in_blob *in = NULL;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import",
		discard_const_p(char *, kwnames),
		&mem_ctx_obj,
		&level,
		&in_obj)) {
		return NULL;
	}
	mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
	if (mem_ctx == NULL) {
		PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
		return NULL;
	}
	in = (union bkrp_data_in_blob *)pytalloc_get_ptr(in_obj);
	if (in == NULL) {
		PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union bkrp_data_in_blob!");
		return NULL;
	}

	return py_import_bkrp_data_in_blob(mem_ctx, level, in);
}

static PyObject *py_bkrp_data_in_blob_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
	PyObject *mem_ctx_obj = NULL;
	TALLOC_CTX *mem_ctx = NULL;
	int level = 0;
	PyObject *in = NULL;
	union bkrp_data_in_blob *out = NULL;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export",
		discard_const_p(char *, kwnames),
		&mem_ctx_obj,
		&level,
		&in)) {
		return NULL;
	}
	mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
	if (mem_ctx == NULL) {
		PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
		return NULL;
	}

	out = py_export_bkrp_data_in_blob(mem_ctx, level, in);
	if (out == NULL) {
		return NULL;
	}

	return pytalloc_GenericObject_reference(out);
}

static PyMethodDef py_bkrp_data_in_blob_methods[] = {
	{ "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_bkrp_data_in_blob_import),
		METH_VARARGS|METH_KEYWORDS|METH_CLASS,
		"T.__import__(mem_ctx, level, in) => ret." },
	{ "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_bkrp_data_in_blob_export),
		METH_VARARGS|METH_KEYWORDS|METH_CLASS,
		"T.__export__(mem_ctx, level, in) => ret." },
	{ NULL, NULL, 0, NULL }
};

static PyObject *py_bkrp_data_in_blob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name);
	return NULL;
}


static PyTypeObject bkrp_data_in_blob_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_data_in_blob",
	.tp_getset = NULL,
	.tp_methods = py_bkrp_data_in_blob_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_data_in_blob_new,
};



static PyObject *py_bkrp_BackupKey_in_get_guidActionAgent(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_guidActionAgent;
	if (object->in.guidActionAgent == NULL) {
		Py_RETURN_NONE;
	}
	py_guidActionAgent = pytalloc_reference_ex(GUID_Type, object->in.guidActionAgent, object->in.guidActionAgent);
	return py_guidActionAgent;
}

static int py_bkrp_BackupKey_in_set_guidActionAgent(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.guidActionAgent));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.guidActionAgent");
		return -1;
	}
	object->in.guidActionAgent = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.guidActionAgent);
	if (object->in.guidActionAgent == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(GUID_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.guidActionAgent = (struct GUID *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_bkrp_BackupKey_in_get_data_in(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_data_in;
	if (object->in.data_in == NULL) {
		Py_RETURN_NONE;
	}
	py_data_in = PyList_New(object->in.data_in_len);
	if (py_data_in == NULL) {
		return NULL;
	}
	{
		int data_in_cntr_1;
		for (data_in_cntr_1 = 0; data_in_cntr_1 < (object->in.data_in_len); data_in_cntr_1++) {
			PyObject *py_data_in_1;
			py_data_in_1 = PyLong_FromLong((uint16_t)object->in.data_in[data_in_cntr_1]);
			PyList_SetItem(py_data_in, data_in_cntr_1, py_data_in_1);
		}
	}
	return py_data_in;
}

static int py_bkrp_BackupKey_in_set_data_in(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.data_in));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data_in");
		return -1;
	}
	object->in.data_in = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.data_in);
	if (object->in.data_in == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int data_in_cntr_1;
		object->in.data_in = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.data_in, PyList_GET_SIZE(value));
		if (!object->in.data_in) { return -1;; }
		talloc_set_name_const(object->in.data_in, "ARRAY: object->in.data_in");
		for (data_in_cntr_1 = 0; data_in_cntr_1 < PyList_GET_SIZE(value); data_in_cntr_1++) {
			if (PyList_GET_ITEM(value, data_in_cntr_1) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data_in[data_in_cntr_1]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.data_in[data_in_cntr_1]));
				if (PyLong_Check(PyList_GET_ITEM(value, data_in_cntr_1))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, data_in_cntr_1));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->in.data_in[data_in_cntr_1] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_BackupKey_in_get_data_in_len(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_data_in_len;
	py_data_in_len = PyLong_FromUnsignedLongLong((uint32_t)object->in.data_in_len);
	return py_data_in_len;
}

static int py_bkrp_BackupKey_in_set_data_in_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data_in_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.data_in_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.data_in_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_BackupKey_out_get_data_out(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_data_out;
	if (object->out.data_out == NULL) {
		Py_RETURN_NONE;
	}
	if (*object->out.data_out == NULL) {
		py_data_out = Py_None;
		Py_INCREF(py_data_out);
	} else {
		py_data_out = PyList_New(*object->out.data_out_len);
		if (py_data_out == NULL) {
			return NULL;
		}
		{
			int data_out_cntr_2;
			for (data_out_cntr_2 = 0; data_out_cntr_2 < (*object->out.data_out_len); data_out_cntr_2++) {
				PyObject *py_data_out_2;
				py_data_out_2 = PyLong_FromLong((uint16_t)*object->out.data_out[data_out_cntr_2]);
				PyList_SetItem(py_data_out, data_out_cntr_2, py_data_out_2);
			}
		}
	}
	return py_data_out;
}

static int py_bkrp_BackupKey_out_set_data_out(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.data_out));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.data_out");
		return -1;
	}
	object->out.data_out = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.data_out);
	if (object->out.data_out == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	if (value == Py_None) {
		*object->out.data_out = NULL;
	} else {
		*object->out.data_out = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int data_out_cntr_2;
			*object->out.data_out = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), *object->out.data_out, PyList_GET_SIZE(value));
			if (!*object->out.data_out) { return -1;; }
			talloc_set_name_const(*object->out.data_out, "ARRAY: *object->out.data_out");
			for (data_out_cntr_2 = 0; data_out_cntr_2 < PyList_GET_SIZE(value); data_out_cntr_2++) {
				if (PyList_GET_ITEM(value, data_out_cntr_2) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *object->out.data_out[data_out_cntr_2]");
					return -1;
				}
				{
					const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.data_out[data_out_cntr_2]));
					if (PyLong_Check(PyList_GET_ITEM(value, data_out_cntr_2))) {
						unsigned long long test_var;
						test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, data_out_cntr_2));
						if (PyErr_Occurred() != NULL) {
							return -1;
						}
						if (test_var > uint_max) {
							PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
							  PyLong_Type.tp_name, uint_max, test_var);
							return -1;
						}
						*object->out.data_out[data_out_cntr_2] = test_var;
					} else {
						PyErr_Format(PyExc_TypeError, "Expected type %s",\
						  PyLong_Type.tp_name);
						return -1;
					}
				}
			}
		}
	}
	return 0;
}

static PyObject *py_bkrp_BackupKey_out_get_data_out_len(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_data_out_len;
	if (object->out.data_out_len == NULL) {
		Py_RETURN_NONE;
	}
	py_data_out_len = PyLong_FromUnsignedLongLong((uint32_t)*object->out.data_out_len);
	return py_data_out_len;
}

static int py_bkrp_BackupKey_out_set_data_out_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.data_out_len));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.data_out_len");
		return -1;
	}
	object->out.data_out_len = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.data_out_len);
	if (object->out.data_out_len == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.data_out_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			*object->out.data_out_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_BackupKey_in_get_param(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_param;
	py_param = PyLong_FromUnsignedLongLong((uint32_t)object->in.param);
	return py_param;
}

static int py_bkrp_BackupKey_in_set_param(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.param");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.param));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.param = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_bkrp_BackupKey_get_result(PyObject *obj, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromWERROR(object->out.result);
	return py_result;
}

static int py_bkrp_BackupKey_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = W_ERROR(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_bkrp_BackupKey_getsetters[] = {
	{
		.name = discard_const_p(char, "in_guidActionAgent"),
		.get = py_bkrp_BackupKey_in_get_guidActionAgent,
		.set = py_bkrp_BackupKey_in_set_guidActionAgent,
		.doc = discard_const_p(char, "PIDL-generated element of base type GUID")
	},
	{
		.name = discard_const_p(char, "in_data_in"),
		.get = py_bkrp_BackupKey_in_get_data_in,
		.set = py_bkrp_BackupKey_in_set_data_in,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "in_data_in_len"),
		.get = py_bkrp_BackupKey_in_get_data_in_len,
		.set = py_bkrp_BackupKey_in_set_data_in_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_data_out"),
		.get = py_bkrp_BackupKey_out_get_data_out,
		.set = py_bkrp_BackupKey_out_set_data_out,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "out_data_out_len"),
		.get = py_bkrp_BackupKey_out_get_data_out_len,
		.set = py_bkrp_BackupKey_out_set_data_out_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_param"),
		.get = py_bkrp_BackupKey_in_get_param,
		.set = py_bkrp_BackupKey_in_set_param,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_bkrp_BackupKey_get_result,
		.set = py_bkrp_BackupKey_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type WERROR")
	},
	{ .name = NULL }
};

static PyObject *py_bkrp_BackupKey_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct bkrp_BackupKey, type);
	struct bkrp_BackupKey *_self = (struct bkrp_BackupKey *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.guidActionAgent = talloc_zero(mem_ctx, struct GUID);
	_self->in.data_in = talloc_zero(mem_ctx, uint8_t);
	/* a pointer to a NULL pointer */
	_self->out.data_out = talloc_zero(mem_ctx, uint8_t *);
	_self->out.data_out_len = talloc_zero(mem_ctx, uint32_t);
	return self;
}

static PyObject *py_bkrp_BackupKey_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(0);
}

static PyObject *py_bkrp_BackupKey_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_backupkey.num_calls < 1) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_bkrp_BackupKey_ndr_pack");
		return NULL;
	}
	call = &ndr_table_backupkey.calls[0];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_bkrp_BackupKey_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_bkrp_BackupKey_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_bkrp_BackupKey_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_bkrp_BackupKey_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_bkrp_BackupKey_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_backupkey.num_calls < 1) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_bkrp_BackupKey_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_backupkey.calls[0];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_bkrp_BackupKey_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

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

	return py_bkrp_BackupKey_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_bkrp_BackupKey_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

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

	return py_bkrp_BackupKey_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_bkrp_BackupKey_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct bkrp_BackupKey *object = (struct bkrp_BackupKey *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_backupkey.num_calls < 1) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_bkrp_BackupKey_ndr_print");
		return NULL;
	}
	call = &ndr_table_backupkey.calls[0];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_bkrp_BackupKey_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_bkrp_BackupKey_ndr_print(py_obj, "bkrp_BackupKey_in", NDR_IN);
}

static PyObject *py_bkrp_BackupKey_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_bkrp_BackupKey_ndr_print(py_obj, "bkrp_BackupKey_out", NDR_OUT);
}

static PyMethodDef py_bkrp_BackupKey_methods[] = {
	{ "opnum", (PyCFunction)py_bkrp_BackupKey_ndr_opnum, METH_NOARGS|METH_CLASS,
		"backupkey.bkrp_BackupKey.opnum() -> 0 (0x00) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_bkrp_BackupKey_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_bkrp_BackupKey_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_bkrp_BackupKey_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_bkrp_BackupKey_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_bkrp_BackupKey_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_bkrp_BackupKey_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject bkrp_BackupKey_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.bkrp_BackupKey",
	.tp_getset = py_bkrp_BackupKey_getsetters,
	.tp_methods = py_bkrp_BackupKey_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_bkrp_BackupKey_new,
};

static bool pack_py_bkrp_BackupKey_args_in(PyObject *args, PyObject *kwargs, struct bkrp_BackupKey *r)
{
	PyObject *py_guidActionAgent;
	PyObject *py_data_in;
	PyObject *py_param;
	const char *kwnames[] = {
		"guidActionAgent", "data_in", "param", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:bkrp_BackupKey", discard_const_p(char *, kwnames), &py_guidActionAgent, &py_data_in, &py_param)) {
		return false;
	}

	if (py_guidActionAgent == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.guidActionAgent");
		return false;
	}
	r->in.guidActionAgent = talloc_ptrtype(r, r->in.guidActionAgent);
	if (r->in.guidActionAgent == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(GUID_Type, py_guidActionAgent, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_guidActionAgent)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.guidActionAgent = (struct GUID *)pytalloc_get_ptr(py_guidActionAgent);
	if (py_data_in == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.data_in");
		return false;
	}
	r->in.data_in = talloc_ptrtype(r, r->in.data_in);
	if (r->in.data_in == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(&PyList_Type, py_data_in, return false;);
	{
		int data_in_cntr_1;
		r->in.data_in = talloc_array_ptrtype(r, r->in.data_in, PyList_GET_SIZE(py_data_in));
		if (!r->in.data_in) { return false;; }
		talloc_set_name_const(r->in.data_in, "ARRAY: r->in.data_in");
		for (data_in_cntr_1 = 0; data_in_cntr_1 < PyList_GET_SIZE(py_data_in); data_in_cntr_1++) {
			if (PyList_GET_ITEM(py_data_in, data_in_cntr_1) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.data_in[data_in_cntr_1]");
				return false;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.data_in[data_in_cntr_1]));
				if (PyLong_Check(PyList_GET_ITEM(py_data_in, data_in_cntr_1))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(py_data_in, data_in_cntr_1));
					if (PyErr_Occurred() != NULL) {
						return false;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return false;
					}
					r->in.data_in[data_in_cntr_1] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return false;
				}
			}
		}
	}
	PY_CHECK_TYPE(&PyList_Type, py_data_in, return false;);
	r->in.data_in_len = PyList_GET_SIZE(py_data_in);
	if (py_param == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.param");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.param));
		if (PyLong_Check(py_param)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_param);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.param = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_bkrp_BackupKey_args_out(struct bkrp_BackupKey *r)
{
	PyObject *result;
	PyObject *py_data_out;
	PyObject *py_data_out_len;
	result = PyTuple_New(2);
	if (*r->out.data_out == NULL) {
		py_data_out = Py_None;
		Py_INCREF(py_data_out);
	} else {
		py_data_out = PyList_New(*r->out.data_out_len);
		if (py_data_out == NULL) {
			return NULL;
		}
		{
			int data_out_cntr_2;
			for (data_out_cntr_2 = 0; data_out_cntr_2 < (*r->out.data_out_len); data_out_cntr_2++) {
				PyObject *py_data_out_2;
				py_data_out_2 = PyLong_FromLong((uint16_t)*r->out.data_out[data_out_cntr_2]);
				PyList_SetItem(py_data_out, data_out_cntr_2, py_data_out_2);
			}
		}
	}
	PyTuple_SetItem(result, 0, py_data_out);
	py_data_out_len = PyLong_FromUnsignedLongLong((uint32_t)*r->out.data_out_len);
	PyTuple_SetItem(result, 1, py_data_out_len);
	if (!W_ERROR_IS_OK(r->out.result)) {
		PyErr_SetWERROR(r->out.result);
		return NULL;
	}

	return result;
}

const struct PyNdrRpcMethodDef py_ndr_backupkey_methods[] = {
	{ "bkrp_BackupKey", "S.bkrp_BackupKey(guidActionAgent, data_in, param) -> (data_out, data_out_len)", (py_dcerpc_call_fn)dcerpc_bkrp_BackupKey_r, (py_data_pack_fn)pack_py_bkrp_BackupKey_args_in, (py_data_unpack_fn)unpack_py_bkrp_BackupKey_args_out, 0, &ndr_table_backupkey },
	{0}
};

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

#define PY_DOC_BACKUPKEY "Remote Backup Key Storage"
static PyTypeObject backupkey_InterfaceType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.backupkey",
	.tp_basicsize = sizeof(dcerpc_InterfaceObject),
	.tp_doc = "backupkey(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_BACKUPKEY,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = interface_backupkey_new,
};

static PyObject *syntax_backupkey_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_backupkey.syntax_id);
}

#define PY_DOC_BACKUPKEY_SYNTAX "Remote Backup Key Storage"
static PyTypeObject backupkey_SyntaxType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "backupkey.backupkey_abstract_syntax",
	.tp_doc = "backupkey_abstract_syntax()\n"PY_DOC_BACKUPKEY_SYNTAX,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = syntax_backupkey_new,
};

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

static struct PyModuleDef moduledef = {
	PyModuleDef_HEAD_INIT,
	.m_name = "backupkey",
	.m_doc = "backupkey DCE/RPC",
	.m_size = -1,
	.m_methods = backupkey_methods,
};
MODULE_INIT_FUNC(backupkey)
{
	PyObject *m = NULL;
	PyObject *dep_samba_dcerpc_misc = NULL;
	PyObject *dep_samba_dcerpc_security = NULL;
	PyObject *dep_talloc = NULL;
	PyObject *dep_samba_dcerpc_base = NULL;

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

	dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
	if (dep_samba_dcerpc_security == NULL)
		goto out;

	dep_talloc = PyImport_ImportModule("talloc");
	if (dep_talloc == NULL)
		goto out;

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

	BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject");
	if (BaseObject_Type == NULL)
		goto out;

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

	dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "dom_sid");
	if (dom_sid_Type == NULL)
		goto out;

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

	ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
	if (ndr_syntax_id_Type == NULL)
		goto out;

	bkrp_exported_RSA_key_pair_Type.tp_base = BaseObject_Type;
	bkrp_exported_RSA_key_pair_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_dc_serverwrap_key_Type.tp_base = BaseObject_Type;
	bkrp_dc_serverwrap_key_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_empty_Type.tp_base = BaseObject_Type;
	bkrp_empty_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_client_side_wrapped_Type.tp_base = BaseObject_Type;
	bkrp_client_side_wrapped_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_client_side_unwrapped_Type.tp_base = BaseObject_Type;
	bkrp_client_side_unwrapped_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_encrypted_secret_v2_Type.tp_base = BaseObject_Type;
	bkrp_encrypted_secret_v2_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_encrypted_secret_v3_Type.tp_base = BaseObject_Type;
	bkrp_encrypted_secret_v3_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_access_check_v2_Type.tp_base = BaseObject_Type;
	bkrp_access_check_v2_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_access_check_v3_Type.tp_base = BaseObject_Type;
	bkrp_access_check_v3_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_rc4encryptedpayload_Type.tp_base = BaseObject_Type;
	bkrp_rc4encryptedpayload_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_server_side_wrapped_Type.tp_base = BaseObject_Type;
	bkrp_server_side_wrapped_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_opaque_blob_Type.tp_base = BaseObject_Type;
	bkrp_opaque_blob_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_data_in_blob_Type.tp_base = BaseObject_Type;
	bkrp_data_in_blob_Type.tp_basicsize = pytalloc_BaseObject_size();

	bkrp_BackupKey_Type.tp_base = BaseObject_Type;
	bkrp_BackupKey_Type.tp_basicsize = pytalloc_BaseObject_size();

	backupkey_InterfaceType.tp_base = ClientConnection_Type;

	backupkey_SyntaxType.tp_base = ndr_syntax_id_Type;
	backupkey_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();

	if (PyType_Ready(&bkrp_exported_RSA_key_pair_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_dc_serverwrap_key_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_empty_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_client_side_wrapped_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_client_side_unwrapped_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_encrypted_secret_v2_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_encrypted_secret_v3_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_access_check_v2_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_access_check_v3_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_rc4encryptedpayload_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_server_side_wrapped_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_opaque_blob_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_data_in_blob_Type) < 0)
		goto out;
	if (PyType_Ready(&bkrp_BackupKey_Type) < 0)
		goto out;
	if (PyType_Ready(&backupkey_InterfaceType) < 0)
		goto out;
	if (PyType_Ready(&backupkey_SyntaxType) < 0)
		goto out;
	if (!PyInterface_AddNdrRpcMethods(&backupkey_InterfaceType, py_ndr_backupkey_methods))
		return NULL;

#ifdef PY_BKRP_EXPORTED_RSA_KEY_PAIR_PATCH
	PY_BKRP_EXPORTED_RSA_KEY_PAIR_PATCH(&bkrp_exported_RSA_key_pair_Type);
#endif
#ifdef PY_BKRP_DC_SERVERWRAP_KEY_PATCH
	PY_BKRP_DC_SERVERWRAP_KEY_PATCH(&bkrp_dc_serverwrap_key_Type);
#endif
#ifdef PY_BKRP_EMPTY_PATCH
	PY_BKRP_EMPTY_PATCH(&bkrp_empty_Type);
#endif
#ifdef PY_BKRP_CLIENT_SIDE_WRAPPED_PATCH
	PY_BKRP_CLIENT_SIDE_WRAPPED_PATCH(&bkrp_client_side_wrapped_Type);
#endif
#ifdef PY_BKRP_CLIENT_SIDE_UNWRAPPED_PATCH
	PY_BKRP_CLIENT_SIDE_UNWRAPPED_PATCH(&bkrp_client_side_unwrapped_Type);
#endif
#ifdef PY_BKRP_ENCRYPTED_SECRET_V2_PATCH
	PY_BKRP_ENCRYPTED_SECRET_V2_PATCH(&bkrp_encrypted_secret_v2_Type);
#endif
#ifdef PY_BKRP_ENCRYPTED_SECRET_V3_PATCH
	PY_BKRP_ENCRYPTED_SECRET_V3_PATCH(&bkrp_encrypted_secret_v3_Type);
#endif
#ifdef PY_BKRP_ACCESS_CHECK_V2_PATCH
	PY_BKRP_ACCESS_CHECK_V2_PATCH(&bkrp_access_check_v2_Type);
#endif
#ifdef PY_BKRP_ACCESS_CHECK_V3_PATCH
	PY_BKRP_ACCESS_CHECK_V3_PATCH(&bkrp_access_check_v3_Type);
#endif
#ifdef PY_BKRP_RC4ENCRYPTEDPAYLOAD_PATCH
	PY_BKRP_RC4ENCRYPTEDPAYLOAD_PATCH(&bkrp_rc4encryptedpayload_Type);
#endif
#ifdef PY_BKRP_SERVER_SIDE_WRAPPED_PATCH
	PY_BKRP_SERVER_SIDE_WRAPPED_PATCH(&bkrp_server_side_wrapped_Type);
#endif
#ifdef PY_BKRP_OPAQUE_BLOB_PATCH
	PY_BKRP_OPAQUE_BLOB_PATCH(&bkrp_opaque_blob_Type);
#endif
#ifdef PY_BKRP_DATA_IN_BLOB_PATCH
	PY_BKRP_DATA_IN_BLOB_PATCH(&bkrp_data_in_blob_Type);
#endif
#ifdef PY_BKRP_BACKUPKEY_PATCH
	PY_BKRP_BACKUPKEY_PATCH(&bkrp_BackupKey_Type);
#endif
#ifdef PY_BACKUPKEY_PATCH
	PY_BACKUPKEY_PATCH(&backupkey_InterfaceType);
#endif
#ifdef PY_BACKUPKEY_ABSTRACT_SYNTAX_PATCH
	PY_BACKUPKEY_ABSTRACT_SYNTAX_PATCH(&backupkey_SyntaxType);
#endif
#ifdef PY_ABSTRACT_SYNTAX_PATCH
	PY_ABSTRACT_SYNTAX_PATCH(&backupkey_SyntaxType);
#endif

	m = PyModule_Create(&moduledef);
	if (m == NULL)
		goto out;

	PyModule_AddObject(m, "BACKUPKEY_RESTORE_GUID", PyUnicode_FromString("47270C64-2FC7-499B-AC5B-0E37CDCE899A"));
	PyModule_AddObject(m, "BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID", PyUnicode_FromString("018FF48A-EABA-40C6-8F6D-72370240E967"));
	PyModule_AddObject(m, "BACKUPKEY_RESTORE_GUID_WIN2K", PyUnicode_FromString("7FE94D50-178E-11D1-AB8F-00805F14DB40"));
	PyModule_AddObject(m, "BACKUPKEY_BACKUP_GUID", PyUnicode_FromString("7F752B10-178E-11D1-AB8F-00805F14DB40"));
	PyModule_AddObject(m, "BACKUPKEY_SERVER_WRAP_VERSION", PyLong_FromLong((uint16_t)BACKUPKEY_SERVER_WRAP_VERSION));
	PyModule_AddObject(m, "BACKUPKEY_CLIENT_WRAP_VERSION2", PyLong_FromLong((uint16_t)BACKUPKEY_CLIENT_WRAP_VERSION2));
	PyModule_AddObject(m, "BACKUPKEY_CLIENT_WRAP_VERSION3", PyLong_FromLong((uint16_t)BACKUPKEY_CLIENT_WRAP_VERSION3));
	PyModule_AddObject(m, "BACKUPKEY_INVALID_GUID_INTEGER", PyLong_FromLong((uint16_t)BACKUPKEY_INVALID_GUID_INTEGER));
	PyModule_AddObject(m, "BACKUPKEY_RESTORE_GUID_INTEGER", PyLong_FromLong((uint16_t)BACKUPKEY_RESTORE_GUID_INTEGER));
	PyModule_AddObject(m, "BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER", PyLong_FromLong((uint16_t)BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID_INTEGER));
	PyModule_AddObject(m, "BACKUPKEY_RESTORE_GUID_WIN2K_INTEGER", PyLong_FromLong((uint16_t)BACKUPKEY_RESTORE_GUID_WIN2K_INTEGER));
	PyModule_AddObject(m, "BACKUPKEY_BACKUP_GUID_INTEGER", PyLong_FromLong((uint16_t)BACKUPKEY_BACKUP_GUID_INTEGER));
	Py_INCREF((PyObject *)(void *)&bkrp_exported_RSA_key_pair_Type);
	PyModule_AddObject(m, "bkrp_exported_RSA_key_pair", (PyObject *)(void *)&bkrp_exported_RSA_key_pair_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_dc_serverwrap_key_Type);
	PyModule_AddObject(m, "bkrp_dc_serverwrap_key", (PyObject *)(void *)&bkrp_dc_serverwrap_key_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_empty_Type);
	PyModule_AddObject(m, "bkrp_empty", (PyObject *)(void *)&bkrp_empty_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_client_side_wrapped_Type);
	PyModule_AddObject(m, "bkrp_client_side_wrapped", (PyObject *)(void *)&bkrp_client_side_wrapped_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_client_side_unwrapped_Type);
	PyModule_AddObject(m, "bkrp_client_side_unwrapped", (PyObject *)(void *)&bkrp_client_side_unwrapped_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_encrypted_secret_v2_Type);
	PyModule_AddObject(m, "bkrp_encrypted_secret_v2", (PyObject *)(void *)&bkrp_encrypted_secret_v2_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_encrypted_secret_v3_Type);
	PyModule_AddObject(m, "bkrp_encrypted_secret_v3", (PyObject *)(void *)&bkrp_encrypted_secret_v3_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_access_check_v2_Type);
	PyModule_AddObject(m, "bkrp_access_check_v2", (PyObject *)(void *)&bkrp_access_check_v2_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_access_check_v3_Type);
	PyModule_AddObject(m, "bkrp_access_check_v3", (PyObject *)(void *)&bkrp_access_check_v3_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_rc4encryptedpayload_Type);
	PyModule_AddObject(m, "bkrp_rc4encryptedpayload", (PyObject *)(void *)&bkrp_rc4encryptedpayload_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_server_side_wrapped_Type);
	PyModule_AddObject(m, "bkrp_server_side_wrapped", (PyObject *)(void *)&bkrp_server_side_wrapped_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_opaque_blob_Type);
	PyModule_AddObject(m, "bkrp_opaque_blob", (PyObject *)(void *)&bkrp_opaque_blob_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_data_in_blob_Type);
	PyModule_AddObject(m, "bkrp_data_in_blob", (PyObject *)(void *)&bkrp_data_in_blob_Type);
	Py_INCREF((PyObject *)(void *)&bkrp_BackupKey_Type);
	PyModule_AddObject(m, "bkrp_BackupKey", (PyObject *)(void *)&bkrp_BackupKey_Type);
	Py_INCREF((PyObject *)(void *)&backupkey_InterfaceType);
	PyModule_AddObject(m, "backupkey", (PyObject *)(void *)&backupkey_InterfaceType);
	Py_INCREF((PyObject *)(void *)&backupkey_SyntaxType);
	PyModule_AddObject(m, "backupkey_abstract_syntax", (PyObject *)(void *)&backupkey_SyntaxType);
	Py_INCREF((PyObject *)(void *)&backupkey_SyntaxType);
	PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&backupkey_SyntaxType);
#ifdef PY_MOD_BACKUPKEY_PATCH
	PY_MOD_BACKUPKEY_PATCH(m);
#endif
	out:
	Py_XDECREF(dep_samba_dcerpc_misc);
	Py_XDECREF(dep_samba_dcerpc_security);
	Py_XDECREF(dep_talloc);
	Py_XDECREF(dep_samba_dcerpc_base);
	return m;

}