text: /* c/zx-cb-aux.c - WARNING: This file was auto generated by xsd2sg.pl. DO NOT EDIT!
   * $Id$ */
  /* Code generation design Copyright (c) 2006 Sampo Kellomaki (sampo@iki.fi),
   * All Rights Reserved. NO WARRANTY. See file COPYING for terms and conditions
   * of use. Some aspects of code generation were driven by schema
   * descriptions that were used as input and may be subject to their own copyright.
   * Code generation uses a template, whose copyright statement follows. */
  
  /** aux-templ.c  -  Auxiliary functions template: cloning, freeing, walking data
   ** Copyright (c) 2010 Sampo Kellomaki (sampo@iki.fi), All Rights Reserved.
   ** Copyright (c) 2006 Symlabs (symlabs@symlabs.com), All Rights Reserved.
   ** Author: Sampo Kellomaki (sampo@iki.fi)
   ** This is confidential unpublished proprietary source code of the author.
   ** NO WARRANTY, not even implied warranties. Contains trade secrets.
   ** Distribution prohibited unless authorized in writing.
   ** Licensed under Apache License 2.0, see file COPYING.
   ** Id: aux-templ.c,v 1.12 2008-10-04 23:42:14 sampo Exp $
   **
   ** 30.5.2006, created, Sampo Kellomaki (sampo@iki.fi)
   ** 6.8.2006, factored from enc-templ.c to separate file --Sampo
   **
   ** N.B: wo=wire order (needed for exc-c14n), so=schema order
   **/
  
  #include <memory.h>
  #include "errmac.h"
  #include "zx.h"
  #include "c/zx-const.h"
  #include "c/zx-data.h"
  #include "c/zx-cb-data.h"
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_By
  #define EL_STRUCT zx_cb_By_s
  #define EL_NS     cb
  #define EL_TAG    By
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_By) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_By(struct zx_ctx* c, struct zx_cb_By_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->sortAlg);
    zx_dup_attr(c, x->sortWeight);
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_By) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_By_s* zx_DEEP_CLONE_cb_By(struct zx_ctx* c, struct zx_cb_By_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_By_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_By_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->sortAlg = zx_clone_attr(c, x->sortAlg);
    x->sortWeight = zx_clone_attr(c, x->sortWeight);
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_By) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_By(struct zx_ctx* c, struct zx_cb_By_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_By) */
  
  int zx_WALK_WO_cb_By(struct zx_ctx* c, struct zx_cb_By_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Create
  #define EL_STRUCT zx_cb_Create_s
  #define EL_NS     cb
  #define EL_TAG    Create
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Create) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Create(struct zx_ctx* c, struct zx_cb_Create_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->ResourceID->gg;
         se && se->g.tok == zx_cb_ResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)se);
    for (se = &x->EncryptedResourceID->gg;
         se && se->g.tok == zx_cb_EncryptedResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)se);
    for (se = &x->Subscription->gg;
         se && se->g.tok == zx_cb_Subscription_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Subscription(c, (struct zx_cb_Subscription_s*)se);
    for (se = &x->CreateItem->gg;
         se && se->g.tok == zx_cb_CreateItem_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_CreateItem(c, (struct zx_cb_CreateItem_s*)se);
    for (se = &x->ItemSelection->gg;
         se && se->g.tok == zx_cb_ItemSelection_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ItemSelection(c, (struct zx_cb_ItemSelection_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Create) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Create_s* zx_DEEP_CLONE_cb_Create(struct zx_ctx* c, struct zx_cb_Create_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Create_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Create_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ResourceID(c,(struct zx_cb_ResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->ResourceID = (struct zx_cb_ResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_EncryptedResourceID(c,(struct zx_cb_EncryptedResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedResourceID = (struct zx_cb_EncryptedResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Subscription->gg;
         e && e->g.tok == zx_cb_Subscription_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Subscription(c,(struct zx_cb_Subscription_s*)e,dup_strs);
    	  if (!enn)
    	      x->Subscription = (struct zx_cb_Subscription_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->CreateItem->gg;
         e && e->g.tok == zx_cb_CreateItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_CreateItem(c,(struct zx_cb_CreateItem_s*)e,dup_strs);
    	  if (!enn)
    	      x->CreateItem = (struct zx_cb_CreateItem_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->ItemSelection->gg;
         e && e->g.tok == zx_cb_ItemSelection_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ItemSelection(c,(struct zx_cb_ItemSelection_s*)e,dup_strs);
    	  if (!enn)
    	      x->ItemSelection = (struct zx_cb_ItemSelection_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Create) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Create(struct zx_ctx* c, struct zx_cb_Create_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Subscription->gg;
         e && e->g.tok == zx_cb_Subscription_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Subscription(c, (struct zx_cb_Subscription_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->CreateItem->gg;
         e && e->g.tok == zx_cb_CreateItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_CreateItem(c, (struct zx_cb_CreateItem_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->ItemSelection->gg;
         e && e->g.tok == zx_cb_ItemSelection_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ItemSelection(c, (struct zx_cb_ItemSelection_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Create) */
  
  int zx_WALK_WO_cb_Create(struct zx_ctx* c, struct zx_cb_Create_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_CreateItem
  #define EL_STRUCT zx_cb_CreateItem_s
  #define EL_NS     cb
  #define EL_TAG    CreateItem
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_CreateItem) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_CreateItem(struct zx_ctx* c, struct zx_cb_CreateItem_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->itemID);
    zx_dup_attr(c, x->objectType);
  
    for (se = &x->NewData->gg;
         se && se->g.tok == zx_cb_NewData_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_NewData(c, (struct zx_cb_NewData_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_CreateItem) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_CreateItem_s* zx_DEEP_CLONE_cb_CreateItem(struct zx_ctx* c, struct zx_cb_CreateItem_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_CreateItem_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_CreateItem_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->itemID = zx_clone_attr(c, x->itemID);
    x->objectType = zx_clone_attr(c, x->objectType);
  
    for (enn = 0, e = &x->NewData->gg;
         e && e->g.tok == zx_cb_NewData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_NewData(c,(struct zx_cb_NewData_s*)e,dup_strs);
    	  if (!enn)
    	      x->NewData = (struct zx_cb_NewData_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_CreateItem) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_CreateItem(struct zx_ctx* c, struct zx_cb_CreateItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->NewData->gg;
         e && e->g.tok == zx_cb_NewData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_NewData(c, (struct zx_cb_NewData_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_CreateItem) */
  
  int zx_WALK_WO_cb_CreateItem(struct zx_ctx* c, struct zx_cb_CreateItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_CreateResponse
  #define EL_STRUCT zx_cb_CreateResponse_s
  #define EL_NS     cb
  #define EL_TAG    CreateResponse
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_CreateResponse) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_CreateResponse(struct zx_ctx* c, struct zx_cb_CreateResponse_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->timeStamp);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
    for (se = &x->ItemData->gg;
         se && se->g.tok == zx_cb_ItemData_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ItemData(c, (struct zx_cb_ItemData_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_CreateResponse) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_CreateResponse_s* zx_DEEP_CLONE_cb_CreateResponse(struct zx_ctx* c, struct zx_cb_CreateResponse_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_CreateResponse_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_CreateResponse_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->timeStamp = zx_clone_attr(c, x->timeStamp);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->ItemData->gg;
         e && e->g.tok == zx_cb_ItemData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ItemData(c,(struct zx_cb_ItemData_s*)e,dup_strs);
    	  if (!enn)
    	      x->ItemData = (struct zx_cb_ItemData_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_CreateResponse) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_CreateResponse(struct zx_ctx* c, struct zx_cb_CreateResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->ItemData->gg;
         e && e->g.tok == zx_cb_ItemData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ItemData(c, (struct zx_cb_ItemData_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_CreateResponse) */
  
  int zx_WALK_WO_cb_CreateResponse(struct zx_ctx* c, struct zx_cb_CreateResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Credential
  #define EL_STRUCT zx_cb_Credential_s
  #define EL_NS     cb
  #define EL_TAG    Credential
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Credential) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Credential(struct zx_ctx* c, struct zx_cb_Credential_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->notOnOrAfter);
  
    for (se = &x->Assertion->gg;
         se && se->g.tok == zx_sa_Assertion_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_sa_Assertion(c, (struct zx_sa_Assertion_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Credential) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Credential_s* zx_DEEP_CLONE_cb_Credential(struct zx_ctx* c, struct zx_cb_Credential_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Credential_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Credential_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->notOnOrAfter = zx_clone_attr(c, x->notOnOrAfter);
  
    for (enn = 0, e = &x->Assertion->gg;
         e && e->g.tok == zx_sa_Assertion_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_sa_Assertion(c,(struct zx_sa_Assertion_s*)e,dup_strs);
    	  if (!enn)
    	      x->Assertion = (struct zx_sa_Assertion_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Credential) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Credential(struct zx_ctx* c, struct zx_cb_Credential_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Assertion->gg;
         e && e->g.tok == zx_sa_Assertion_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_sa_Assertion(c, (struct zx_sa_Assertion_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Credential) */
  
  int zx_WALK_WO_cb_Credential(struct zx_ctx* c, struct zx_cb_Credential_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Data
  #define EL_STRUCT zx_cb_Data_s
  #define EL_NS     cb
  #define EL_TAG    Data
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Data) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Data(struct zx_ctx* c, struct zx_cb_Data_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->itemIDRef);
    zx_dup_attr(c, x->nextOffset);
    zx_dup_attr(c, x->notSorted);
    zx_dup_attr(c, x->remaining);
    zx_dup_attr(c, x->setID);
    zx_dup_attr(c, x->changeFormat);
  
    zx_dup_strs_simple_elems(c, x->Card);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Data) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Data_s* zx_DEEP_CLONE_cb_Data(struct zx_ctx* c, struct zx_cb_Data_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Data_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Data_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->itemIDRef = zx_clone_attr(c, x->itemIDRef);
    x->nextOffset = zx_clone_attr(c, x->nextOffset);
    x->notSorted = zx_clone_attr(c, x->notSorted);
    x->remaining = zx_clone_attr(c, x->remaining);
    x->setID = zx_clone_attr(c, x->setID);
    x->changeFormat = zx_clone_attr(c, x->changeFormat);
  
    x->Card = zx_deep_clone_simple_elems(c,x->Card, dup_strs);
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Data) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Data(struct zx_ctx* c, struct zx_cb_Data_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->Card, ctx, callback);
    if (ret)
      return ret;
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Data) */
  
  int zx_WALK_WO_cb_Data(struct zx_ctx* c, struct zx_cb_Data_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Delete
  #define EL_STRUCT zx_cb_Delete_s
  #define EL_NS     cb
  #define EL_TAG    Delete
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Delete) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Delete(struct zx_ctx* c, struct zx_cb_Delete_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->ResourceID->gg;
         se && se->g.tok == zx_cb_ResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)se);
    for (se = &x->EncryptedResourceID->gg;
         se && se->g.tok == zx_cb_EncryptedResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)se);
    for (se = &x->DeleteItem->gg;
         se && se->g.tok == zx_cb_DeleteItem_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_DeleteItem(c, (struct zx_cb_DeleteItem_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Delete) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Delete_s* zx_DEEP_CLONE_cb_Delete(struct zx_ctx* c, struct zx_cb_Delete_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Delete_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Delete_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ResourceID(c,(struct zx_cb_ResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->ResourceID = (struct zx_cb_ResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_EncryptedResourceID(c,(struct zx_cb_EncryptedResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedResourceID = (struct zx_cb_EncryptedResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->DeleteItem->gg;
         e && e->g.tok == zx_cb_DeleteItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_DeleteItem(c,(struct zx_cb_DeleteItem_s*)e,dup_strs);
    	  if (!enn)
    	      x->DeleteItem = (struct zx_cb_DeleteItem_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Delete) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Delete(struct zx_ctx* c, struct zx_cb_Delete_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->DeleteItem->gg;
         e && e->g.tok == zx_cb_DeleteItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_DeleteItem(c, (struct zx_cb_DeleteItem_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Delete) */
  
  int zx_WALK_WO_cb_Delete(struct zx_ctx* c, struct zx_cb_Delete_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_DeleteItem
  #define EL_STRUCT zx_cb_DeleteItem_s
  #define EL_NS     cb
  #define EL_TAG    DeleteItem
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_DeleteItem) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_DeleteItem(struct zx_ctx* c, struct zx_cb_DeleteItem_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->itemID);
    zx_dup_attr(c, x->notChangedSince);
    zx_dup_attr(c, x->objectType);
    zx_dup_attr(c, x->predefined);
  
    zx_dup_strs_simple_elems(c, x->Select);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_DeleteItem) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_DeleteItem_s* zx_DEEP_CLONE_cb_DeleteItem(struct zx_ctx* c, struct zx_cb_DeleteItem_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_DeleteItem_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_DeleteItem_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->itemID = zx_clone_attr(c, x->itemID);
    x->notChangedSince = zx_clone_attr(c, x->notChangedSince);
    x->objectType = zx_clone_attr(c, x->objectType);
    x->predefined = zx_clone_attr(c, x->predefined);
  
    x->Select = zx_deep_clone_simple_elems(c,x->Select, dup_strs);
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_DeleteItem) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_DeleteItem(struct zx_ctx* c, struct zx_cb_DeleteItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->Select, ctx, callback);
    if (ret)
      return ret;
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_DeleteItem) */
  
  int zx_WALK_WO_cb_DeleteItem(struct zx_ctx* c, struct zx_cb_DeleteItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_DeleteResponse
  #define EL_STRUCT zx_cb_DeleteResponse_s
  #define EL_NS     cb
  #define EL_TAG    DeleteResponse
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_DeleteResponse) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_DeleteResponse(struct zx_ctx* c, struct zx_cb_DeleteResponse_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_DeleteResponse) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_DeleteResponse_s* zx_DEEP_CLONE_cb_DeleteResponse(struct zx_ctx* c, struct zx_cb_DeleteResponse_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_DeleteResponse_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_DeleteResponse_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_DeleteResponse) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_DeleteResponse(struct zx_ctx* c, struct zx_cb_DeleteResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_DeleteResponse) */
  
  int zx_WALK_WO_cb_DeleteResponse(struct zx_ctx* c, struct zx_cb_DeleteResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_EncryptedResourceID
  #define EL_STRUCT zx_cb_EncryptedResourceID_s
  #define EL_NS     cb
  #define EL_TAG    EncryptedResourceID
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_EncryptedResourceID) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_EncryptedResourceID(struct zx_ctx* c, struct zx_cb_EncryptedResourceID_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    for (se = &x->EncryptedData->gg;
         se && se->g.tok == zx_xenc_EncryptedData_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_xenc_EncryptedData(c, (struct zx_xenc_EncryptedData_s*)se);
    for (se = &x->EncryptedKey->gg;
         se && se->g.tok == zx_xenc_EncryptedKey_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_xenc_EncryptedKey(c, (struct zx_xenc_EncryptedKey_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_EncryptedResourceID) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_EncryptedResourceID_s* zx_DEEP_CLONE_cb_EncryptedResourceID(struct zx_ctx* c, struct zx_cb_EncryptedResourceID_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_EncryptedResourceID_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_EncryptedResourceID_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    for (enn = 0, e = &x->EncryptedData->gg;
         e && e->g.tok == zx_xenc_EncryptedData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_xenc_EncryptedData(c,(struct zx_xenc_EncryptedData_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedData = (struct zx_xenc_EncryptedData_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->EncryptedKey->gg;
         e && e->g.tok == zx_xenc_EncryptedKey_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_xenc_EncryptedKey(c,(struct zx_xenc_EncryptedKey_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedKey = (struct zx_xenc_EncryptedKey_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_EncryptedResourceID) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_EncryptedResourceID(struct zx_ctx* c, struct zx_cb_EncryptedResourceID_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->EncryptedData->gg;
         e && e->g.tok == zx_xenc_EncryptedData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_xenc_EncryptedData(c, (struct zx_xenc_EncryptedData_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->EncryptedKey->gg;
         e && e->g.tok == zx_xenc_EncryptedKey_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_xenc_EncryptedKey(c, (struct zx_xenc_EncryptedKey_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_EncryptedResourceID) */
  
  int zx_WALK_WO_cb_EncryptedResourceID(struct zx_ctx* c, struct zx_cb_EncryptedResourceID_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Extension
  #define EL_STRUCT zx_cb_Extension_s
  #define EL_NS     cb
  #define EL_TAG    Extension
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Extension) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Extension(struct zx_ctx* c, struct zx_cb_Extension_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Extension) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Extension_s* zx_DEEP_CLONE_cb_Extension(struct zx_ctx* c, struct zx_cb_Extension_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Extension_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Extension_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Extension) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Extension(struct zx_ctx* c, struct zx_cb_Extension_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Extension) */
  
  int zx_WALK_WO_cb_Extension(struct zx_ctx* c, struct zx_cb_Extension_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_ItemData
  #define EL_STRUCT zx_cb_ItemData_s
  #define EL_NS     cb
  #define EL_TAG    ItemData
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_ItemData) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_ItemData(struct zx_ctx* c, struct zx_cb_ItemData_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->itemIDRef);
    zx_dup_attr(c, x->notSorted);
    zx_dup_attr(c, x->changeFormat);
  
    zx_dup_strs_simple_elems(c, x->Card);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_ItemData) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_ItemData_s* zx_DEEP_CLONE_cb_ItemData(struct zx_ctx* c, struct zx_cb_ItemData_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_ItemData_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_ItemData_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->itemIDRef = zx_clone_attr(c, x->itemIDRef);
    x->notSorted = zx_clone_attr(c, x->notSorted);
    x->changeFormat = zx_clone_attr(c, x->changeFormat);
  
    x->Card = zx_deep_clone_simple_elems(c,x->Card, dup_strs);
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_ItemData) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_ItemData(struct zx_ctx* c, struct zx_cb_ItemData_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->Card, ctx, callback);
    if (ret)
      return ret;
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_ItemData) */
  
  int zx_WALK_WO_cb_ItemData(struct zx_ctx* c, struct zx_cb_ItemData_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_ItemSelection
  #define EL_STRUCT zx_cb_ItemSelection_s
  #define EL_NS     cb
  #define EL_TAG    ItemSelection
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_ItemSelection) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_ItemSelection(struct zx_ctx* c, struct zx_cb_ItemSelection_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->format);
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_ItemSelection) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_ItemSelection_s* zx_DEEP_CLONE_cb_ItemSelection(struct zx_ctx* c, struct zx_cb_ItemSelection_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_ItemSelection_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_ItemSelection_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->format = zx_clone_attr(c, x->format);
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_ItemSelection) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_ItemSelection(struct zx_ctx* c, struct zx_cb_ItemSelection_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_ItemSelection) */
  
  int zx_WALK_WO_cb_ItemSelection(struct zx_ctx* c, struct zx_cb_ItemSelection_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Modification
  #define EL_STRUCT zx_cb_Modification_s
  #define EL_NS     cb
  #define EL_TAG    Modification
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Modification) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Modification(struct zx_ctx* c, struct zx_cb_Modification_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->itemID);
    zx_dup_attr(c, x->notChangedSince);
    zx_dup_attr(c, x->objectType);
    zx_dup_attr(c, x->overrideAllowed);
  
    zx_dup_strs_simple_elems(c, x->Select);
    for (se = &x->NewData->gg;
         se && se->g.tok == zx_cb_NewData_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_NewData(c, (struct zx_cb_NewData_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Modification) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Modification_s* zx_DEEP_CLONE_cb_Modification(struct zx_ctx* c, struct zx_cb_Modification_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Modification_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Modification_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->itemID = zx_clone_attr(c, x->itemID);
    x->notChangedSince = zx_clone_attr(c, x->notChangedSince);
    x->objectType = zx_clone_attr(c, x->objectType);
    x->overrideAllowed = zx_clone_attr(c, x->overrideAllowed);
  
    x->Select = zx_deep_clone_simple_elems(c,x->Select, dup_strs);
    for (enn = 0, e = &x->NewData->gg;
         e && e->g.tok == zx_cb_NewData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_NewData(c,(struct zx_cb_NewData_s*)e,dup_strs);
    	  if (!enn)
    	      x->NewData = (struct zx_cb_NewData_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Modification) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Modification(struct zx_ctx* c, struct zx_cb_Modification_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->Select, ctx, callback);
    if (ret)
      return ret;
    for (e = &x->NewData->gg;
         e && e->g.tok == zx_cb_NewData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_NewData(c, (struct zx_cb_NewData_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Modification) */
  
  int zx_WALK_WO_cb_Modification(struct zx_ctx* c, struct zx_cb_Modification_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Modify
  #define EL_STRUCT zx_cb_Modify_s
  #define EL_NS     cb
  #define EL_TAG    Modify
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Modify) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Modify(struct zx_ctx* c, struct zx_cb_Modify_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->ResourceID->gg;
         se && se->g.tok == zx_cb_ResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)se);
    for (se = &x->EncryptedResourceID->gg;
         se && se->g.tok == zx_cb_EncryptedResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)se);
    for (se = &x->Subscription->gg;
         se && se->g.tok == zx_cb_Subscription_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Subscription(c, (struct zx_cb_Subscription_s*)se);
    for (se = &x->Modification->gg;
         se && se->g.tok == zx_cb_Modification_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Modification(c, (struct zx_cb_Modification_s*)se);
    for (se = &x->ItemSelection->gg;
         se && se->g.tok == zx_cb_ItemSelection_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ItemSelection(c, (struct zx_cb_ItemSelection_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Modify) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Modify_s* zx_DEEP_CLONE_cb_Modify(struct zx_ctx* c, struct zx_cb_Modify_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Modify_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Modify_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ResourceID(c,(struct zx_cb_ResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->ResourceID = (struct zx_cb_ResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_EncryptedResourceID(c,(struct zx_cb_EncryptedResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedResourceID = (struct zx_cb_EncryptedResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Subscription->gg;
         e && e->g.tok == zx_cb_Subscription_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Subscription(c,(struct zx_cb_Subscription_s*)e,dup_strs);
    	  if (!enn)
    	      x->Subscription = (struct zx_cb_Subscription_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Modification->gg;
         e && e->g.tok == zx_cb_Modification_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Modification(c,(struct zx_cb_Modification_s*)e,dup_strs);
    	  if (!enn)
    	      x->Modification = (struct zx_cb_Modification_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->ItemSelection->gg;
         e && e->g.tok == zx_cb_ItemSelection_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ItemSelection(c,(struct zx_cb_ItemSelection_s*)e,dup_strs);
    	  if (!enn)
    	      x->ItemSelection = (struct zx_cb_ItemSelection_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Modify) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Modify(struct zx_ctx* c, struct zx_cb_Modify_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Subscription->gg;
         e && e->g.tok == zx_cb_Subscription_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Subscription(c, (struct zx_cb_Subscription_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Modification->gg;
         e && e->g.tok == zx_cb_Modification_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Modification(c, (struct zx_cb_Modification_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->ItemSelection->gg;
         e && e->g.tok == zx_cb_ItemSelection_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ItemSelection(c, (struct zx_cb_ItemSelection_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Modify) */
  
  int zx_WALK_WO_cb_Modify(struct zx_ctx* c, struct zx_cb_Modify_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_ModifyResponse
  #define EL_STRUCT zx_cb_ModifyResponse_s
  #define EL_NS     cb
  #define EL_TAG    ModifyResponse
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_ModifyResponse) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_ModifyResponse(struct zx_ctx* c, struct zx_cb_ModifyResponse_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->timeStamp);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
    for (se = &x->ItemData->gg;
         se && se->g.tok == zx_cb_ItemData_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ItemData(c, (struct zx_cb_ItemData_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_ModifyResponse) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_ModifyResponse_s* zx_DEEP_CLONE_cb_ModifyResponse(struct zx_ctx* c, struct zx_cb_ModifyResponse_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_ModifyResponse_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_ModifyResponse_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->timeStamp = zx_clone_attr(c, x->timeStamp);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->ItemData->gg;
         e && e->g.tok == zx_cb_ItemData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ItemData(c,(struct zx_cb_ItemData_s*)e,dup_strs);
    	  if (!enn)
    	      x->ItemData = (struct zx_cb_ItemData_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_ModifyResponse) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_ModifyResponse(struct zx_ctx* c, struct zx_cb_ModifyResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->ItemData->gg;
         e && e->g.tok == zx_cb_ItemData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ItemData(c, (struct zx_cb_ItemData_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_ModifyResponse) */
  
  int zx_WALK_WO_cb_ModifyResponse(struct zx_ctx* c, struct zx_cb_ModifyResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_NewData
  #define EL_STRUCT zx_cb_NewData_s
  #define EL_NS     cb
  #define EL_TAG    NewData
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_NewData) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_NewData(struct zx_ctx* c, struct zx_cb_NewData_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    zx_dup_strs_simple_elems(c, x->Card);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_NewData) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_NewData_s* zx_DEEP_CLONE_cb_NewData(struct zx_ctx* c, struct zx_cb_NewData_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_NewData_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_NewData_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    x->Card = zx_deep_clone_simple_elems(c,x->Card, dup_strs);
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_NewData) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_NewData(struct zx_ctx* c, struct zx_cb_NewData_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->Card, ctx, callback);
    if (ret)
      return ret;
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_NewData) */
  
  int zx_WALK_WO_cb_NewData(struct zx_ctx* c, struct zx_cb_NewData_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Notification
  #define EL_STRUCT zx_cb_Notification_s
  #define EL_NS     cb
  #define EL_TAG    Notification
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Notification) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Notification(struct zx_ctx* c, struct zx_cb_Notification_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->endReason);
    zx_dup_attr(c, x->expires);
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->subscriptionID);
  
    for (se = &x->ItemData->gg;
         se && se->g.tok == zx_cb_ItemData_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ItemData(c, (struct zx_cb_ItemData_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Notification) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Notification_s* zx_DEEP_CLONE_cb_Notification(struct zx_ctx* c, struct zx_cb_Notification_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Notification_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Notification_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->endReason = zx_clone_attr(c, x->endReason);
    x->expires = zx_clone_attr(c, x->expires);
    x->id = zx_clone_attr(c, x->id);
    x->subscriptionID = zx_clone_attr(c, x->subscriptionID);
  
    for (enn = 0, e = &x->ItemData->gg;
         e && e->g.tok == zx_cb_ItemData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ItemData(c,(struct zx_cb_ItemData_s*)e,dup_strs);
    	  if (!enn)
    	      x->ItemData = (struct zx_cb_ItemData_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Notification) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Notification(struct zx_ctx* c, struct zx_cb_Notification_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ItemData->gg;
         e && e->g.tok == zx_cb_ItemData_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ItemData(c, (struct zx_cb_ItemData_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Notification) */
  
  int zx_WALK_WO_cb_Notification(struct zx_ctx* c, struct zx_cb_Notification_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Notify
  #define EL_STRUCT zx_cb_Notify_s
  #define EL_NS     cb
  #define EL_TAG    Notify
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Notify) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Notify(struct zx_ctx* c, struct zx_cb_Notify_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->timeStamp);
  
    for (se = &x->Notification->gg;
         se && se->g.tok == zx_cb_Notification_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Notification(c, (struct zx_cb_Notification_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Notify) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Notify_s* zx_DEEP_CLONE_cb_Notify(struct zx_ctx* c, struct zx_cb_Notify_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Notify_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Notify_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->timeStamp = zx_clone_attr(c, x->timeStamp);
  
    for (enn = 0, e = &x->Notification->gg;
         e && e->g.tok == zx_cb_Notification_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Notification(c,(struct zx_cb_Notification_s*)e,dup_strs);
    	  if (!enn)
    	      x->Notification = (struct zx_cb_Notification_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Notify) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Notify(struct zx_ctx* c, struct zx_cb_Notify_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Notification->gg;
         e && e->g.tok == zx_cb_Notification_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Notification(c, (struct zx_cb_Notification_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Notify) */
  
  int zx_WALK_WO_cb_Notify(struct zx_ctx* c, struct zx_cb_Notify_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_NotifyAdminTo
  #define EL_STRUCT zx_cb_NotifyAdminTo_s
  #define EL_NS     cb
  #define EL_TAG    NotifyAdminTo
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_NotifyAdminTo) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_NotifyAdminTo(struct zx_ctx* c, struct zx_cb_NotifyAdminTo_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    zx_dup_strs_simple_elems(c, x->SecurityMechID);
    for (se = &x->Credential->gg;
         se && se->g.tok == zx_cb_Credential_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Credential(c, (struct zx_cb_Credential_s*)se);
    zx_dup_strs_simple_elems(c, x->Endpoint);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_NotifyAdminTo) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_NotifyAdminTo_s* zx_DEEP_CLONE_cb_NotifyAdminTo(struct zx_ctx* c, struct zx_cb_NotifyAdminTo_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_NotifyAdminTo_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_NotifyAdminTo_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    x->SecurityMechID = zx_deep_clone_simple_elems(c,x->SecurityMechID, dup_strs);
    for (enn = 0, e = &x->Credential->gg;
         e && e->g.tok == zx_cb_Credential_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Credential(c,(struct zx_cb_Credential_s*)e,dup_strs);
    	  if (!enn)
    	      x->Credential = (struct zx_cb_Credential_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    x->Endpoint = zx_deep_clone_simple_elems(c,x->Endpoint, dup_strs);
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_NotifyAdminTo) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_NotifyAdminTo(struct zx_ctx* c, struct zx_cb_NotifyAdminTo_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->SecurityMechID, ctx, callback);
    if (ret)
      return ret;
    for (e = &x->Credential->gg;
         e && e->g.tok == zx_cb_Credential_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Credential(c, (struct zx_cb_Credential_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    ret = zx_walk_so_simple_elems(c, x->Endpoint, ctx, callback);
    if (ret)
      return ret;
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_NotifyAdminTo) */
  
  int zx_WALK_WO_cb_NotifyAdminTo(struct zx_ctx* c, struct zx_cb_NotifyAdminTo_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_NotifyResponse
  #define EL_STRUCT zx_cb_NotifyResponse_s
  #define EL_NS     cb
  #define EL_TAG    NotifyResponse
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_NotifyResponse) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_NotifyResponse(struct zx_ctx* c, struct zx_cb_NotifyResponse_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_NotifyResponse) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_NotifyResponse_s* zx_DEEP_CLONE_cb_NotifyResponse(struct zx_ctx* c, struct zx_cb_NotifyResponse_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_NotifyResponse_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_NotifyResponse_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_NotifyResponse) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_NotifyResponse(struct zx_ctx* c, struct zx_cb_NotifyResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_NotifyResponse) */
  
  int zx_WALK_WO_cb_NotifyResponse(struct zx_ctx* c, struct zx_cb_NotifyResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_NotifyTo
  #define EL_STRUCT zx_cb_NotifyTo_s
  #define EL_NS     cb
  #define EL_TAG    NotifyTo
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_NotifyTo) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_NotifyTo(struct zx_ctx* c, struct zx_cb_NotifyTo_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    zx_dup_strs_simple_elems(c, x->SecurityMechID);
    for (se = &x->Credential->gg;
         se && se->g.tok == zx_cb_Credential_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Credential(c, (struct zx_cb_Credential_s*)se);
    zx_dup_strs_simple_elems(c, x->Endpoint);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_NotifyTo) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_NotifyTo_s* zx_DEEP_CLONE_cb_NotifyTo(struct zx_ctx* c, struct zx_cb_NotifyTo_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_NotifyTo_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_NotifyTo_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    x->SecurityMechID = zx_deep_clone_simple_elems(c,x->SecurityMechID, dup_strs);
    for (enn = 0, e = &x->Credential->gg;
         e && e->g.tok == zx_cb_Credential_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Credential(c,(struct zx_cb_Credential_s*)e,dup_strs);
    	  if (!enn)
    	      x->Credential = (struct zx_cb_Credential_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    x->Endpoint = zx_deep_clone_simple_elems(c,x->Endpoint, dup_strs);
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_NotifyTo) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_NotifyTo(struct zx_ctx* c, struct zx_cb_NotifyTo_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    ret = zx_walk_so_simple_elems(c, x->SecurityMechID, ctx, callback);
    if (ret)
      return ret;
    for (e = &x->Credential->gg;
         e && e->g.tok == zx_cb_Credential_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Credential(c, (struct zx_cb_Credential_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    ret = zx_walk_so_simple_elems(c, x->Endpoint, ctx, callback);
    if (ret)
      return ret;
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_NotifyTo) */
  
  int zx_WALK_WO_cb_NotifyTo(struct zx_ctx* c, struct zx_cb_NotifyTo_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Query
  #define EL_STRUCT zx_cb_Query_s
  #define EL_NS     cb
  #define EL_TAG    Query
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Query) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Query(struct zx_ctx* c, struct zx_cb_Query_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->ResourceID->gg;
         se && se->g.tok == zx_cb_ResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)se);
    for (se = &x->EncryptedResourceID->gg;
         se && se->g.tok == zx_cb_EncryptedResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)se);
    for (se = &x->Subscription->gg;
         se && se->g.tok == zx_cb_Subscription_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Subscription(c, (struct zx_cb_Subscription_s*)se);
    for (se = &x->QueryItem->gg;
         se && se->g.tok == zx_cb_QueryItem_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_QueryItem(c, (struct zx_cb_QueryItem_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Query) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Query_s* zx_DEEP_CLONE_cb_Query(struct zx_ctx* c, struct zx_cb_Query_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Query_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Query_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ResourceID(c,(struct zx_cb_ResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->ResourceID = (struct zx_cb_ResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_EncryptedResourceID(c,(struct zx_cb_EncryptedResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedResourceID = (struct zx_cb_EncryptedResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Subscription->gg;
         e && e->g.tok == zx_cb_Subscription_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Subscription(c,(struct zx_cb_Subscription_s*)e,dup_strs);
    	  if (!enn)
    	      x->Subscription = (struct zx_cb_Subscription_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->QueryItem->gg;
         e && e->g.tok == zx_cb_QueryItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_QueryItem(c,(struct zx_cb_QueryItem_s*)e,dup_strs);
    	  if (!enn)
    	      x->QueryItem = (struct zx_cb_QueryItem_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Query) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Query(struct zx_ctx* c, struct zx_cb_Query_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Subscription->gg;
         e && e->g.tok == zx_cb_Subscription_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Subscription(c, (struct zx_cb_Subscription_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->QueryItem->gg;
         e && e->g.tok == zx_cb_QueryItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_QueryItem(c, (struct zx_cb_QueryItem_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Query) */
  
  int zx_WALK_WO_cb_Query(struct zx_ctx* c, struct zx_cb_Query_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_QueryItem
  #define EL_STRUCT zx_cb_QueryItem_s
  #define EL_NS     cb
  #define EL_TAG    QueryItem
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_QueryItem) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_QueryItem(struct zx_ctx* c, struct zx_cb_QueryItem_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->count);
    zx_dup_attr(c, x->offset);
    zx_dup_attr(c, x->setID);
    zx_dup_attr(c, x->setReq);
    zx_dup_attr(c, x->format);
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_QueryItem) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_QueryItem_s* zx_DEEP_CLONE_cb_QueryItem(struct zx_ctx* c, struct zx_cb_QueryItem_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_QueryItem_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_QueryItem_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->count = zx_clone_attr(c, x->count);
    x->offset = zx_clone_attr(c, x->offset);
    x->setID = zx_clone_attr(c, x->setID);
    x->setReq = zx_clone_attr(c, x->setReq);
    x->format = zx_clone_attr(c, x->format);
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_QueryItem) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_QueryItem(struct zx_ctx* c, struct zx_cb_QueryItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_QueryItem) */
  
  int zx_WALK_WO_cb_QueryItem(struct zx_ctx* c, struct zx_cb_QueryItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_QueryResponse
  #define EL_STRUCT zx_cb_QueryResponse_s
  #define EL_NS     cb
  #define EL_TAG    QueryResponse
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_QueryResponse) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_QueryResponse(struct zx_ctx* c, struct zx_cb_QueryResponse_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->itemIDRef);
    zx_dup_attr(c, x->timeStamp);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
    for (se = &x->Data->gg;
         se && se->g.tok == zx_cb_Data_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Data(c, (struct zx_cb_Data_s*)se);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_QueryResponse) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_QueryResponse_s* zx_DEEP_CLONE_cb_QueryResponse(struct zx_ctx* c, struct zx_cb_QueryResponse_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_QueryResponse_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_QueryResponse_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
    x->itemIDRef = zx_clone_attr(c, x->itemIDRef);
    x->timeStamp = zx_clone_attr(c, x->timeStamp);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Data->gg;
         e && e->g.tok == zx_cb_Data_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Data(c,(struct zx_cb_Data_s*)e,dup_strs);
    	  if (!enn)
    	      x->Data = (struct zx_cb_Data_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_QueryResponse) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_QueryResponse(struct zx_ctx* c, struct zx_cb_QueryResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Data->gg;
         e && e->g.tok == zx_cb_Data_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Data(c, (struct zx_cb_Data_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_QueryResponse) */
  
  int zx_WALK_WO_cb_QueryResponse(struct zx_ctx* c, struct zx_cb_QueryResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_RefItem
  #define EL_STRUCT zx_cb_RefItem_s
  #define EL_NS     cb
  #define EL_TAG    RefItem
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_RefItem) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_RefItem(struct zx_ctx* c, struct zx_cb_RefItem_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->ItemIDRef);
    zx_dup_attr(c, x->subscriptionID);
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_RefItem) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_RefItem_s* zx_DEEP_CLONE_cb_RefItem(struct zx_ctx* c, struct zx_cb_RefItem_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_RefItem_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_RefItem_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->ItemIDRef = zx_clone_attr(c, x->ItemIDRef);
    x->subscriptionID = zx_clone_attr(c, x->subscriptionID);
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_RefItem) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_RefItem(struct zx_ctx* c, struct zx_cb_RefItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_RefItem) */
  
  int zx_WALK_WO_cb_RefItem(struct zx_ctx* c, struct zx_cb_RefItem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_ReportUsage
  #define EL_STRUCT zx_cb_ReportUsage_s
  #define EL_NS     cb
  #define EL_TAG    ReportUsage
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_ReportUsage) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_ReportUsage(struct zx_ctx* c, struct zx_cb_ReportUsage_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->ResourceID->gg;
         se && se->g.tok == zx_cb_ResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)se);
    for (se = &x->EncryptedResourceID->gg;
         se && se->g.tok == zx_cb_EncryptedResourceID_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)se);
    zx_dup_strs_simple_elems(c, x->CARDID);
    for (se = &x->UsageType->gg;
         se && se->g.tok == zx_cb_UsageType_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_UsageType(c, (struct zx_cb_UsageType_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_ReportUsage) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_ReportUsage_s* zx_DEEP_CLONE_cb_ReportUsage(struct zx_ctx* c, struct zx_cb_ReportUsage_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_ReportUsage_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_ReportUsage_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ResourceID(c,(struct zx_cb_ResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->ResourceID = (struct zx_cb_ResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_EncryptedResourceID(c,(struct zx_cb_EncryptedResourceID_s*)e,dup_strs);
    	  if (!enn)
    	      x->EncryptedResourceID = (struct zx_cb_EncryptedResourceID_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    x->CARDID = zx_deep_clone_simple_elems(c,x->CARDID, dup_strs);
    for (enn = 0, e = &x->UsageType->gg;
         e && e->g.tok == zx_cb_UsageType_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_UsageType(c,(struct zx_cb_UsageType_s*)e,dup_strs);
    	  if (!enn)
    	      x->UsageType = (struct zx_cb_UsageType_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_ReportUsage) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_ReportUsage(struct zx_ctx* c, struct zx_cb_ReportUsage_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ResourceID->gg;
         e && e->g.tok == zx_cb_ResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ResourceID(c, (struct zx_cb_ResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->EncryptedResourceID->gg;
         e && e->g.tok == zx_cb_EncryptedResourceID_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_EncryptedResourceID(c, (struct zx_cb_EncryptedResourceID_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    ret = zx_walk_so_simple_elems(c, x->CARDID, ctx, callback);
    if (ret)
      return ret;
    for (e = &x->UsageType->gg;
         e && e->g.tok == zx_cb_UsageType_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_UsageType(c, (struct zx_cb_UsageType_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_ReportUsage) */
  
  int zx_WALK_WO_cb_ReportUsage(struct zx_ctx* c, struct zx_cb_ReportUsage_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_ReportUsageResponse
  #define EL_STRUCT zx_cb_ReportUsageResponse_s
  #define EL_NS     cb
  #define EL_TAG    ReportUsageResponse
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_ReportUsageResponse) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_ReportUsageResponse(struct zx_ctx* c, struct zx_cb_ReportUsageResponse_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_ReportUsageResponse) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_ReportUsageResponse_s* zx_DEEP_CLONE_cb_ReportUsageResponse(struct zx_ctx* c, struct zx_cb_ReportUsageResponse_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_ReportUsageResponse_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_ReportUsageResponse_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_ReportUsageResponse) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_ReportUsageResponse(struct zx_ctx* c, struct zx_cb_ReportUsageResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_ReportUsageResponse) */
  
  int zx_WALK_WO_cb_ReportUsageResponse(struct zx_ctx* c, struct zx_cb_ReportUsageResponse_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_ResourceID
  #define EL_STRUCT zx_cb_ResourceID_s
  #define EL_NS     cb
  #define EL_TAG    ResourceID
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_ResourceID) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_ResourceID(struct zx_ctx* c, struct zx_cb_ResourceID_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->id);
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_ResourceID) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_ResourceID_s* zx_DEEP_CLONE_cb_ResourceID(struct zx_ctx* c, struct zx_cb_ResourceID_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_ResourceID_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_ResourceID_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->id = zx_clone_attr(c, x->id);
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_ResourceID) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_ResourceID(struct zx_ctx* c, struct zx_cb_ResourceID_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_ResourceID) */
  
  int zx_WALK_WO_cb_ResourceID(struct zx_ctx* c, struct zx_cb_ResourceID_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Status
  #define EL_STRUCT zx_cb_Status_s
  #define EL_NS     cb
  #define EL_TAG    Status
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Status) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Status(struct zx_ctx* c, struct zx_cb_Status_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->code);
    zx_dup_attr(c, x->comment);
    zx_dup_attr(c, x->ref);
  
    for (se = &x->Status->gg;
         se && se->g.tok == zx_cb_Status_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Status(c, (struct zx_cb_Status_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Status) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Status_s* zx_DEEP_CLONE_cb_Status(struct zx_ctx* c, struct zx_cb_Status_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Status_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Status_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->code = zx_clone_attr(c, x->code);
    x->comment = zx_clone_attr(c, x->comment);
    x->ref = zx_clone_attr(c, x->ref);
  
    for (enn = 0, e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Status(c,(struct zx_cb_Status_s*)e,dup_strs);
    	  if (!enn)
    	      x->Status = (struct zx_cb_Status_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Status) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Status(struct zx_ctx* c, struct zx_cb_Status_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->Status->gg;
         e && e->g.tok == zx_cb_Status_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Status(c, (struct zx_cb_Status_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Status) */
  
  int zx_WALK_WO_cb_Status(struct zx_ctx* c, struct zx_cb_Status_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_Subscription
  #define EL_STRUCT zx_cb_Subscription_s
  #define EL_NS     cb
  #define EL_TAG    Subscription
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_Subscription) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_Subscription(struct zx_ctx* c, struct zx_cb_Subscription_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->expires);
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->includeData);
    zx_dup_attr(c, x->starts);
    zx_dup_attr(c, x->subscriptionID);
  
    for (se = &x->ItemSelection->gg;
         se && se->g.tok == zx_cb_ItemSelection_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_ItemSelection(c, (struct zx_cb_ItemSelection_s*)se);
    for (se = &x->RefItem->gg;
         se && se->g.tok == zx_cb_RefItem_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_RefItem(c, (struct zx_cb_RefItem_s*)se);
    for (se = &x->NotifyTo->gg;
         se && se->g.tok == zx_cb_NotifyTo_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_NotifyTo(c, (struct zx_cb_NotifyTo_s*)se);
    for (se = &x->NotifyAdminTo->gg;
         se && se->g.tok == zx_cb_NotifyAdminTo_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_NotifyAdminTo(c, (struct zx_cb_NotifyAdminTo_s*)se);
    zx_dup_strs_simple_elems(c, x->Aggregation);
    zx_dup_strs_simple_elems(c, x->Trigger);
    for (se = &x->Extension->gg;
         se && se->g.tok == zx_cb_Extension_ELEM;
         se = (struct zx_elem_s*)se->g.n)
      zx_DUP_STRS_cb_Extension(c, (struct zx_cb_Extension_s*)se);
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_Subscription) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_Subscription_s* zx_DEEP_CLONE_cb_Subscription(struct zx_ctx* c, struct zx_cb_Subscription_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_Subscription_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_Subscription_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->expires = zx_clone_attr(c, x->expires);
    x->id = zx_clone_attr(c, x->id);
    x->includeData = zx_clone_attr(c, x->includeData);
    x->starts = zx_clone_attr(c, x->starts);
    x->subscriptionID = zx_clone_attr(c, x->subscriptionID);
  
    for (enn = 0, e = &x->ItemSelection->gg;
         e && e->g.tok == zx_cb_ItemSelection_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_ItemSelection(c,(struct zx_cb_ItemSelection_s*)e,dup_strs);
    	  if (!enn)
    	      x->ItemSelection = (struct zx_cb_ItemSelection_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->RefItem->gg;
         e && e->g.tok == zx_cb_RefItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_RefItem(c,(struct zx_cb_RefItem_s*)e,dup_strs);
    	  if (!enn)
    	      x->RefItem = (struct zx_cb_RefItem_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->NotifyTo->gg;
         e && e->g.tok == zx_cb_NotifyTo_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_NotifyTo(c,(struct zx_cb_NotifyTo_s*)e,dup_strs);
    	  if (!enn)
    	      x->NotifyTo = (struct zx_cb_NotifyTo_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    for (enn = 0, e = &x->NotifyAdminTo->gg;
         e && e->g.tok == zx_cb_NotifyAdminTo_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_NotifyAdminTo(c,(struct zx_cb_NotifyAdminTo_s*)e,dup_strs);
    	  if (!enn)
    	      x->NotifyAdminTo = (struct zx_cb_NotifyAdminTo_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
    x->Aggregation = zx_deep_clone_simple_elems(c,x->Aggregation, dup_strs);
    x->Trigger = zx_deep_clone_simple_elems(c,x->Trigger, dup_strs);
    for (enn = 0, e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
    	  en=(struct zx_elem_s*)zx_DEEP_CLONE_cb_Extension(c,(struct zx_cb_Extension_s*)e,dup_strs);
    	  if (!enn)
    	      x->Extension = (struct zx_cb_Extension_s*)en;
    	  else
    	      enn->g.n = &en->g;
    	  enn = en;
    }
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_Subscription) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_Subscription(struct zx_ctx* c, struct zx_cb_Subscription_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
    for (e = &x->ItemSelection->gg;
         e && e->g.tok == zx_cb_ItemSelection_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_ItemSelection(c, (struct zx_cb_ItemSelection_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->RefItem->gg;
         e && e->g.tok == zx_cb_RefItem_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_RefItem(c, (struct zx_cb_RefItem_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->NotifyTo->gg;
         e && e->g.tok == zx_cb_NotifyTo_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_NotifyTo(c, (struct zx_cb_NotifyTo_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    for (e = &x->NotifyAdminTo->gg;
         e && e->g.tok == zx_cb_NotifyAdminTo_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_NotifyAdminTo(c, (struct zx_cb_NotifyAdminTo_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
    ret = zx_walk_so_simple_elems(c, x->Aggregation, ctx, callback);
    if (ret)
      return ret;
    ret = zx_walk_so_simple_elems(c, x->Trigger, ctx, callback);
    if (ret)
      return ret;
    for (e = &x->Extension->gg;
         e && e->g.tok == zx_cb_Extension_ELEM;
         e = (struct zx_elem_s*)e->g.n) {
      ret = zx_WALK_SO_cb_Extension(c, (struct zx_cb_Extension_s*)e, ctx, callback);
      if (ret)
        return ret;
    }
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_Subscription) */
  
  int zx_WALK_WO_cb_Subscription(struct zx_ctx* c, struct zx_cb_Subscription_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  
  
  #ifdef EL_NAME
  #undef EL_NAME
  #endif
  #ifdef EL_STRUCT
  #undef EL_STRUCT
  #endif
  #ifdef EL_NS
  #undef EL_NS
  #endif
  #ifdef EL_TAG
  #undef EL_TAG
  #endif
  
  #define EL_NAME   cb_UsageType
  #define EL_STRUCT zx_cb_UsageType_s
  #define EL_NS     cb
  #define EL_TAG    UsageType
  
  #ifdef ZX_ENA_AUX
  
  /* FUNC(zx_DUP_STRS_cb_UsageType) */
  
  /* Depth first traversal of data structure to copy its simple strings
   * to memory allocated from the memory allocator. The decoder will
   * use the underlying wireprotocol PDU buffer for strings, i.e.
   * strings are not copied - they point to the real data. If the
   * datastructure needs to outlast the protocol data or needs a different
   * memory allocation strategy, you need to call this function.  */
  
  /* Called by: */
  void zx_DUP_STRS_cb_UsageType(struct zx_ctx* c, struct zx_cb_UsageType_s* x)
  {
    struct zx_elem_s* se  MAYBE_UNUSED;
    zx_dup_strs_common(c, &x->gg);
    /* *** deal with xmlns specifications in exc c14n way */
  
    zx_dup_attr(c, x->success);
    zx_dup_attr(c, x->ACC);
    zx_dup_attr(c, x->ACCTime);
    zx_dup_attr(c, x->id);
    zx_dup_attr(c, x->modificationTime);
    zx_dup_attr(c, x->modifier);
  
  
  }
  
  /* FUNC(zx_DEEP_CLONE_cb_UsageType) */
  
  /* Depth first traversal of data structure to clone it and its sublements.
   * The simple strings are handled as a special case according to dup_strs flag. */
  
  /* Called by: */
  struct zx_cb_UsageType_s* zx_DEEP_CLONE_cb_UsageType(struct zx_ctx* c, struct zx_cb_UsageType_s* x, int dup_strs)
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    struct zx_elem_s* en  MAYBE_UNUSED;
    struct zx_elem_s* enn MAYBE_UNUSED;
  
    x = (struct zx_cb_UsageType_s*)zx_clone_elem_common(c, &x->gg, sizeof(struct zx_cb_UsageType_s), dup_strs);
    /* *** deal with xmlns specifications in exc c14n way */
  
    x->success = zx_clone_attr(c, x->success);
    x->ACC = zx_clone_attr(c, x->ACC);
    x->ACCTime = zx_clone_attr(c, x->ACCTime);
    x->id = zx_clone_attr(c, x->id);
    x->modificationTime = zx_clone_attr(c, x->modificationTime);
    x->modifier = zx_clone_attr(c, x->modifier);
  
  
    return x;
  }
  
  /* FUNC(zx_WALK_SO_cb_UsageType) */
  
  /* Depth first traversal of the tree in either schema order or the wire order. */
   
  int zx_WALK_SO_cb_UsageType(struct zx_ctx* c, struct zx_cb_UsageType_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    struct zx_elem_s* e   MAYBE_UNUSED;
    int ret = callback(&x->gg.g, ctx);
    if (ret)
      return ret;
    
    /* *** deal with xmlns specifications in exc c14n way */
  
  
    
    ret = zx_walk_so_unknown_attributes(c, &x->gg, ctx, callback); 
    if (ret)
      return ret;
  
  
    
    return zx_walk_so_unknown_elems_and_content(c, &x->gg, ctx, callback);
  }
  
  /* FUNC(zx_WALK_WO_cb_UsageType) */
  
  int zx_WALK_WO_cb_UsageType(struct zx_ctx* c, struct zx_cb_UsageType_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
  {
    ERR("*** walk_wo not implemented %d", 0);
    return 0;
  }
  
  #endif
  
  
  /* EOF -- c/zx-cb-aux.c */
  